BPF List
 help / color / mirror / Atom feed
* [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress
@ 2026-11-19 14:22 Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect() Nikolay Aleksandrov
                   ` (7 more replies)
  0 siblings, 8 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Nikolay Aleksandrov, Alexei Starovoitov, Daniel Borkmann,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, John Fastabend,
	Stanislav Fomichev, David S. Miller, Eric Dumazet, Jakub Kicinski,
	Paolo Abeni, Simon Horman, Joe Stringer, Paul Chaignon,
	Alasdair McWilliam, netdev

Hi,
This patch-set is based on Daniel's [1] original set that adds support for
bpf_sk_assign on egress. It is useful for the TPROXY use case which needs
to assign a listening socket (e.g. Envoy) to an skb on egress, other
potential use cases are to attribute forwarded traffic to a specific
established socket for qdisc flow classification (fq, fq_codel) or cgroup
accounting. In order to support bpf_sk_assign on SOCK_RCU_FREE sockets, a
reference is taken and a specific destructor that unconditionally releases
it is installed (sock_pfree_ref). That destructor is used throughout to
recognize such skb. For more information please see the individual commit
messages.

There are a few limitations, also noted in the commit messages,
more importantly:
 - software GSO splitting after assignment is unsupported
 - decrypted egress skbs are unsupported
 - loopback discards egress assignments

Maybe this can be applied to a feature branch on bpf-next and then pulled to
bpf-next/master and net-next/main so both trees would have the original
commits and not duplicates.

With the kind help of friendly LLMs there're 19 new selftests that exercise
various sk assign (16 egress and 3 ingress) scenarios such as:
 - egress reuseport (4 tests)
 - ingress redirects (2 tests)
 - egress redirects and drops (4 tests)
 - classic tc actions (3 tests)
 - netkit proxy delivery (2 tests)
 - netkit with NFQUEUE (4 tests)

Thank you,
 Nik

[1] https://github.com/cilium/linux/commits/pr/bpf-tproxy/

CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: John Fastabend <john.fastabend@gmail.com>
CC: Stanislav Fomichev <sdf@fomichev.me>
CC: David S. Miller <davem@davemloft.net>
CC: Eric Dumazet <edumazet@kernel.org>
CC: Jakub Kicinski <kuba@kernel.org>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Simon Horman <horms@kernel.org>
CC: Joe Stringer <joe@wand.net.nz>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>
CC: netdev@vger.kernel.org

Daniel Borkmann (3):
  bpf: Orphan prefetched sk on skb_do_redirect()
  bpf: allow bpf_sk_assign on tc egress with refcounted sockets
  bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress

Nikolay Aleksandrov (5):
  net: track references owned by prefetched socket assignments
  selftests/bpf: Delete assign_reuse namespace when opening it fails
  selftests/bpf: Cover egress socket assignment with reuseport
  selftests/bpf: Exercise netkit socket assignment to a host proxy
  selftests/bpf: Check assigned socket lifetime across queues and drops

 .../chelsio/inline_crypto/ch_ktls/chcr_ktls.c |   5 +-
 include/net/inet6_hashtables.h                |  10 +-
 include/net/inet_hashtables.h                 |  10 +-
 include/net/request_sock.h                    |   8 +-
 include/net/sock.h                            |   4 +-
 include/uapi/linux/bpf.h                      |   9 +-
 net/core/filter.c                             |  22 +-
 net/core/sock.c                               |  11 +
 net/netfilter/nf_queue.c                      |  16 +-
 net/sched/act_bpf.c                           |   4 +-
 net/tls/tls_device_fallback.c                 |   5 +-
 tools/include/uapi/linux/bpf.h                |   9 +-
 tools/testing/selftests/bpf/config            |   5 +
 tools/testing/selftests/bpf/netlink_helpers.c |   3 +-
 .../selftests/bpf/prog_tests/assign_reuse.c   | 625 +++++++++++++++++-
 .../bpf/prog_tests/sk_assign_netkit.c         | 586 ++++++++++++++++
 .../selftests/bpf/progs/sk_assign_lifetime.c  | 182 +++++
 .../selftests/bpf/progs/sk_assign_netkit.c    | 153 +++++
 .../selftests/bpf/progs/test_assign_reuse.c   | 174 ++++-
 tools/testing/selftests/bpf/unpriv_helpers.c  |  16 +
 tools/testing/selftests/bpf/unpriv_helpers.h  |   2 +
 21 files changed, 1794 insertions(+), 65 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
 create mode 100644 tools/testing/selftests/bpf/progs/sk_assign_lifetime.c
 create mode 100644 tools/testing/selftests/bpf/progs/sk_assign_netkit.c

-- 
2.47.3


^ permalink raw reply	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect()
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 14:52   ` sashiko-bot
  2026-11-19 14:22 ` [PATCH bpf-next 2/8] net: track references owned by prefetched socket assignments Nikolay Aleksandrov
                   ` (6 subsequent siblings)
  7 siblings, 1 reply; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Daniel Borkmann, Nikolay Aleksandrov, Alexei Starovoitov,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, John Fastabend,
	Stanislav Fomichev, David S. Miller, Eric Dumazet, Jakub Kicinski,
	Paolo Abeni, Simon Horman, Joe Stringer, Paul Chaignon,
	Alasdair McWilliam, netdev

From: Daniel Borkmann <daniel@iogearbox.net>

Ingress bpf_sk_assign() can borrow an RCU-protected listener. Redirecting
to a qdisc or receive backlog can outlive that protection.

Orphan prefetched assignments before potentially queued redirects,
including peer egress. Keep synchronous peer-ingress handoff unchanged.

Fixes: 7ae215d23c12 ("bpf: Don't refcount LISTEN sockets in sk_assign()")
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: John Fastabend <john.fastabend@gmail.com>
CC: Stanislav Fomichev <sdf@fomichev.me>
CC: David S. Miller <davem@davemloft.net>
CC: Eric Dumazet <edumazet@kernel.org>
CC: Jakub Kicinski <kuba@kernel.org>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Simon Horman <horms@kernel.org>
CC: Joe Stringer <joe@wand.net.nz>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>
CC: netdev@vger.kernel.org

 net/core/filter.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/net/core/filter.c b/net/core/filter.c
index 946b07a17fce..1ad57a371534 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -2558,6 +2558,15 @@ int skb_do_redirect(struct sk_buff *skb)
 	ri->flags = 0;
 	if (unlikely(!dev))
 		goto out_drop;
+
+	/*
+	 * Prefetched sockets may borrow a listener under RCU. Orphan them
+	 * before redirects that can outlive this section. Peer ingress
+	 * stays in the same RCU section.
+	 */
+	if (skb_sk_is_prefetched(skb) &&
+	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
+		skb_orphan(skb);
 	if (flags & BPF_F_PEER) {
 		dev = skb_get_peer_dev(dev);
 		if (unlikely(!dev ||
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 2/8] net: track references owned by prefetched socket assignments
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect() Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets Nikolay Aleksandrov
                   ` (5 subsequent siblings)
  7 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Nikolay Aleksandrov, Paul Chaignon, Alasdair McWilliam,
	David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
	Simon Horman, Kuniyuki Iwashima, Willem de Bruijn,
	Pablo Neira Ayuso, Florian Westphal, Phil Sutter, netdev,
	netfilter-devel, coreteam, Alexei Starovoitov, Daniel Borkmann,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, John Fastabend,
	Stanislav Fomichev

Add sock_pfree_ref() for skb-owned references whose release must not
depend on SOCK_RCU_FREE. Teach receive lookup, NFQUEUE and reuseport
selection to preserve and transfer this ownership for egress assignment.
This ownership bookkeeping is needed for subsequent patches that allow
bpf_sk_assign to be used in egress paths.

Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>
CC: David S. Miller <davem@davemloft.net>
CC: Eric Dumazet <edumazet@kernel.org>
CC: Jakub Kicinski <kuba@kernel.org>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Simon Horman <horms@kernel.org>
CC: Kuniyuki Iwashima <kuniyu@google.com>
CC: Willem de Bruijn <willemb@google.com>
CC: Pablo Neira Ayuso <pablo@netfilter.org>
CC: Florian Westphal <fw@strlen.de>
CC: Phil Sutter <phil@nwl.cc>
CC: netdev@vger.kernel.org
CC: netfilter-devel@vger.kernel.org
CC: coreteam@netfilter.org
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: John Fastabend <john.fastabend@gmail.com>
CC: Stanislav Fomichev <sdf@fomichev.me>

 include/net/inet6_hashtables.h | 10 +++++++---
 include/net/inet_hashtables.h  | 10 +++++++---
 include/net/request_sock.h     |  8 +++++---
 include/net/sock.h             |  4 +++-
 net/core/sock.c                |  7 +++++++
 net/netfilter/nf_queue.c       | 16 +++++++---------
 6 files changed, 36 insertions(+), 19 deletions(-)

diff --git a/include/net/inet6_hashtables.h b/include/net/inet6_hashtables.h
index 2cc5d416bbb5..5a109a48cc14 100644
--- a/include/net/inet6_hashtables.h
+++ b/include/net/inet6_hashtables.h
@@ -134,10 +134,14 @@ struct sock *inet6_steal_sock(struct net *net, struct sk_buff *skb, int doff,
 	if (!reuse_sk)
 		return sk;
 
-	/* We've chosen a new reuseport sock which is never refcounted. This
-	 * implies that sk also isn't refcounted.
+	/* egress bpf assignment can hold a reference on the prefetched
+	 * socket and reuseport returns an rcu protected socket so if it
+	 * differs we have to release the original reference
 	 */
-	WARN_ON_ONCE(*refcounted);
+	if (reuse_sk != sk && *refcounted) {
+		sock_put(sk);
+		*refcounted = false;
+	}
 
 	return reuse_sk;
 }
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 6e2fe186d0dc..787bf9e394a8 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -474,10 +474,14 @@ struct sock *inet_steal_sock(struct net *net, struct sk_buff *skb, int doff,
 	if (!reuse_sk)
 		return sk;
 
-	/* We've chosen a new reuseport sock which is never refcounted. This
-	 * implies that sk also isn't refcounted.
+	/* egress bpf assignment can hold a reference on the prefetched
+	 * socket and reuseport returns an rcu protected socket so if it
+	 * differs we have to release the original reference
 	 */
-	WARN_ON_ONCE(*refcounted);
+	if (reuse_sk != sk && *refcounted) {
+		sock_put(sk);
+		*refcounted = false;
+	}
 
 	return reuse_sk;
 }
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index faa6dc49cea8..1d1204e4f754 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -103,6 +103,8 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb,
 	}
 
 	*prefetched = skb_sk_is_prefetched(skb);
+	*refcounted = true;
+#ifdef CONFIG_INET
 	if (*prefetched) {
 #if IS_ENABLED(CONFIG_SYN_COOKIES)
 		if (sk->sk_state == TCP_NEW_SYN_RECV && inet_reqsk(sk)->syncookie) {
@@ -114,10 +116,10 @@ static inline struct sock *skb_steal_sock(struct sk_buff *skb,
 			return sk;
 		}
 #endif
-		*refcounted = sk_is_refcounted(sk);
-	} else {
-		*refcounted = true;
+		*refcounted = skb->destructor == sock_pfree_ref ||
+			      sk_is_refcounted(sk);
 	}
+#endif
 
 	skb->destructor = NULL;
 	skb->sk = NULL;
diff --git a/include/net/sock.h b/include/net/sock.h
index 3144efad8c36..33cc361e941f 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -1874,6 +1874,7 @@ void sock_efree(struct sk_buff *skb);
 #ifdef CONFIG_INET
 void sock_edemux(struct sk_buff *skb);
 void sock_pfree(struct sk_buff *skb);
+void sock_pfree_ref(struct sk_buff *skb);
 
 static inline void skb_set_owner_edemux(struct sk_buff *skb, struct sock *sk)
 {
@@ -3034,7 +3035,8 @@ static inline bool
 skb_sk_is_prefetched(struct sk_buff *skb)
 {
 #ifdef CONFIG_INET
-	return skb->destructor == sock_pfree;
+	return skb->destructor == sock_pfree ||
+	       skb->destructor == sock_pfree_ref;
 #else
 	return false;
 #endif /* CONFIG_INET */
diff --git a/net/core/sock.c b/net/core/sock.c
index ad414878dc5b..3b1f60eaa73e 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -2871,6 +2871,13 @@ void sock_pfree(struct sk_buff *skb)
 	sock_gen_put(sk);
 }
 EXPORT_SYMBOL(sock_pfree);
+
+/* variant of sock_pfree for sockets where a refcount was explicitly taken */
+void sock_pfree_ref(struct sk_buff *skb)
+{
+	sock_gen_put(skb->sk);
+}
+EXPORT_SYMBOL(sock_pfree_ref);
 #endif /* CONFIG_INET */
 
 /*
diff --git a/net/netfilter/nf_queue.c b/net/netfilter/nf_queue.c
index bd603e3a99a5..d920a67b6fa0 100644
--- a/net/netfilter/nf_queue.c
+++ b/net/netfilter/nf_queue.c
@@ -195,17 +195,15 @@ static int __nf_queue(struct sk_buff *skb, const struct nf_hook_state *state,
 		break;
 	}
 
-	if (skb_sk_is_prefetched(skb)) {
-		struct sock *sk = skb->sk;
-
-		if (!sk_is_refcounted(sk)) {
-			if (!refcount_inc_not_zero(&sk->sk_refcnt))
-				return -ENOTCONN;
+#ifdef CONFIG_INET
+	if (skb->destructor == sock_pfree && !sk_is_refcounted(skb->sk)) {
+		if (!refcount_inc_not_zero(&skb->sk->sk_refcnt))
+			return -ENOTCONN;
 
-			/* drop refcount on skb_orphan */
-			skb->destructor = sock_edemux;
-		}
+		/* drop refcount on skb_orphan */
+		skb->destructor = sock_edemux;
 	}
+#endif
 
 	entry = kmalloc(sizeof(*entry) + route_key_size, GFP_ATOMIC);
 	if (!entry)
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect() Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 2/8] net: track references owned by prefetched socket assignments Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 15:19   ` bot+bpf-ci
  2026-11-19 15:28   ` sashiko-bot
  2026-11-19 14:22 ` [PATCH bpf-next 4/8] bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress Nikolay Aleksandrov
                   ` (4 subsequent siblings)
  7 siblings, 2 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Daniel Borkmann, Nikolay Aleksandrov, Ayush Sawal, Andrew Lunn,
	David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
	Alexei Starovoitov, Andrii Nakryiko, Eduard Zingerman,
	Kumar Kartikeya Dwivedi, Martin KaFai Lau, Song Liu,
	Yonghong Song, Jiri Olsa, Emil Tsalapatis, Ihor Solodrai,
	John Fastabend, Stanislav Fomichev, Simon Horman,
	Kuniyuki Iwashima, Willem de Bruijn, Jamal Hadi Salim, Jiri Pirko,
	Sabrina Dubroca, Paul Chaignon, Alasdair McWilliam, netdev

From: Daniel Borkmann <daniel@iogearbox.net>

bpf_sk_assign() has been limited to tc ingress because the assigned
socket may be a SOCK_RCU_FREE listener held without a refcount, relying
on the current RCU read-side section for its lifetime. That assumption
breaks on egress where the skb can sit in a qdisc across grace periods.
However, the helper is also useful on the egress path, for example to
attribute forwarded traffic to a specific established socket for qdisc
flow classification (fq, fq_codel), cgroup accounting, or SO_PRIORITY
propagation. Established sockets are refcounted and therefore safe to
pin on an skb that may be queued.

Allow TC egress to assign full refcounted sockets, taking an skb-owned
reference after orphaning any previous send-side owner. Preserve it
across redirects, classic BPF verdicts and netem delay. Reject decrypted
egress skbs to preserve the original TLS transmit owner.

Using sock_pfree_ref as a destructor encodes the refcount state so:

  - sock_pfree_ref releases the refcount on drop (unlike sock_pfree
    which skips non-refcounted sockets).
  - skb_sk_is_prefetched recognizes both destructors so ip_rcv_core
    still skips the skb_orphan on the receive side.
  - skb_steal_sock sets refcounted=true for sock_pfree_ref so the
    transport layer calls sock_put after consuming the socket.
  - skb_do_redirect only orphans sock_pfree + !sk_is_refcounted (the
    true no-refcount case from ingress), preserving sock_pfree_ref
    sockets across redirects.

The refcount_inc_not_zero cost per bpf_sk_assign call is negligible
relative to the BPF program and the sk_lookup that precedes it, and
does not affect the UDP early demux path which continues to use
sock_pfree without a refcount.

Handle reference-only ownership in TLS software fallback and Chelsio
record reconstruction without sk_wmem_alloc charges or lost references.

Software GSO splitting after assignment is unsupported, including qdisc,
device/driver/tunnel fallback and netkit peer-side NFQUEUE segmentation.
Segments can lose the selected socket; intact GSO and assignment after
segmentation remain supported. Ordinary loopback and veth peer NAPI/GRO
preparation can also discard the assignment, even without GSO.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Ayush Sawal <ayush.sawal@chelsio.com>
CC: Andrew Lunn <andrew+netdev@lunn.ch>
CC: David S. Miller <davem@davemloft.net>
CC: Eric Dumazet <edumazet@kernel.org>
CC: Jakub Kicinski <kuba@kernel.org>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: John Fastabend <john.fastabend@gmail.com>
CC: Stanislav Fomichev <sdf@fomichev.me>
CC: Simon Horman <horms@kernel.org>
CC: Kuniyuki Iwashima <kuniyu@google.com>
CC: Willem de Bruijn <willemb@google.com>
CC: Jamal Hadi Salim <jhs@mojatatu.com>
CC: Jiri Pirko <jiri@resnulli.us>
CC: Sabrina Dubroca <sd@queasysnail.net>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>
CC: netdev@vger.kernel.org

 .../chelsio/inline_crypto/ch_ktls/chcr_ktls.c |  5 ++++-
 include/uapi/linux/bpf.h                      |  8 ++++---
 net/core/filter.c                             | 22 +++++++++++++------
 net/core/sock.c                               |  4 ++++
 net/sched/act_bpf.c                           |  4 +++-
 net/tls/tls_device_fallback.c                 |  5 +++--
 tools/include/uapi/linux/bpf.h                |  8 ++++---
 7 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c b/drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c
index 4d645771596a..796497e9d3b9 100644
--- a/drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c
+++ b/drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c
@@ -1669,7 +1669,10 @@ static void chcr_ktls_copy_record_in_skb(struct sk_buff *nskb,
 	nskb->truesize += record->len;
 	nskb->sk = skb->sk;
 	nskb->destructor = skb->destructor;
-	refcount_add(nskb->truesize, &nskb->sk->sk_wmem_alloc);
+	if (nskb->destructor == sock_pfree_ref)
+		sock_hold(nskb->sk);
+	else
+		refcount_add(nskb->truesize, &nskb->sk->sk_wmem_alloc);
 }
 
 /*
diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index 62de0919db72..45e3018fb2ae 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -4611,7 +4611,9 @@ union bpf_attr {
  *		**bpf_clone_redirect**\ () or other methods outside of BPF may
  *		interfere with successful delivery to the socket.
  *
- *		This operation is only valid from TC ingress path.
+ *		This operation is valid from TC ingress and egress paths.
+ *		On egress, only full refcounted sockets are accepted.
+ *		Software GSO segmentation after assignment is unsupported.
  *
  *		The *flags* argument must be zero.
  *	Return
@@ -4623,8 +4625,8 @@ union bpf_attr {
  *
  *		**-ENETUNREACH** if the socket is unreachable (wrong netns).
  *
- *		**-EOPNOTSUPP** if the operation is not supported, for example
- *		a call from outside of TC ingress.
+ *		**-EOPNOTSUPP** if the socket is unhashed, or TC egress uses
+ *		a non-full or non-refcounted socket or a decrypted packet.
  *
  * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags)
  *	Description
diff --git a/net/core/filter.c b/net/core/filter.c
index 1ad57a371534..feeb752f7a00 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -2559,14 +2559,17 @@ int skb_do_redirect(struct sk_buff *skb)
 	if (unlikely(!dev))
 		goto out_drop;
 
+#ifdef CONFIG_INET
 	/*
-	 * Prefetched sockets may borrow a listener under RCU. Orphan them
-	 * before redirects that can outlive this section. Peer ingress
-	 * stays in the same RCU section.
+	 * Prefetched listeners may be borrowed under RCU. Drop borrowed
+	 * assignments before redirects that can outlive this section.
+	 * Peer ingress stays in the same RCU section.
 	 */
-	if (skb_sk_is_prefetched(skb) &&
+	if (skb->destructor == sock_pfree &&
+	    !sk_is_refcounted(skb->sk) &&
 	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
 		skb_orphan(skb);
+#endif
 	if (flags & BPF_F_PEER) {
 		dev = skb_get_peer_dev(dev);
 		if (unlikely(!dev ||
@@ -8115,21 +8118,26 @@ static const struct bpf_func_proto bpf_tcp_gen_syncookie_proto = {
 
 BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)
 {
+	bool egress = !skb_at_tc_ingress(skb);
+	bool refcounted;
+
 	if (!sk || flags != 0)
 		return -EINVAL;
-	if (!skb_at_tc_ingress(skb))
+	if (egress && (!sk_fullsock(sk) || !sk_is_refcounted(sk) ||
+		       skb_is_decrypted(skb)))
 		return -EOPNOTSUPP;
+	refcounted = egress || sk_is_refcounted(sk);
 	if (unlikely(dev_net(skb->dev) != sock_net(sk)))
 		return -ENETUNREACH;
 	if (sk_unhashed(sk))
 		return -EOPNOTSUPP;
-	if (sk_is_refcounted(sk) &&
+	if (refcounted &&
 	    unlikely(!refcount_inc_not_zero_acquire(&sk->sk_refcnt)))
 		return -ENOENT;
 
 	skb_orphan(skb);
 	skb->sk = sk;
-	skb->destructor = sock_pfree;
+	skb->destructor = egress ? sock_pfree_ref : sock_pfree;
 
 	return 0;
 }
diff --git a/net/core/sock.c b/net/core/sock.c
index 3b1f60eaa73e..f4ec58a86056 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -2818,6 +2818,10 @@ static bool can_skb_orphan_partial(const struct sk_buff *skb)
  */
 void skb_orphan_partial(struct sk_buff *skb)
 {
+#ifdef CONFIG_INET
+	if (skb->destructor == sock_pfree_ref)
+		return;
+#endif
 	if (skb_is_tcp_pure_ack(skb))
 		return;
 
diff --git a/net/sched/act_bpf.c b/net/sched/act_bpf.c
index 06d8f78b7368..a0918fe9a71a 100644
--- a/net/sched/act_bpf.c
+++ b/net/sched/act_bpf.c
@@ -54,8 +54,10 @@ TC_INDIRECT_SCOPE int tcf_bpf_act(struct sk_buff *skb,
 	}
 	if (unlikely(!skb->tstamp && skb->tstamp_type))
 		skb->tstamp_type = SKB_CLOCK_REALTIME;
-	if (skb_sk_is_prefetched(skb) && filter_res != TC_ACT_OK)
+#ifdef CONFIG_INET
+	if (skb->destructor == sock_pfree && filter_res != TC_ACT_OK)
 		skb_orphan(skb);
+#endif
 
 	/* A BPF program may overwrite the default action opcode.
 	 * Similarly as in cls_bpf, if filter_res == -1 we use the
diff --git a/net/tls/tls_device_fallback.c b/net/tls/tls_device_fallback.c
index b547027cc879..1450335a94dc 100644
--- a/net/tls/tls_device_fallback.c
+++ b/net/tls/tls_device_fallback.c
@@ -194,8 +194,9 @@ static void complete_skb(struct sk_buff *nskb, struct sk_buff *skb, int headln)
 
 	update_chksum(nskb, headln);
 
-	/* sock_efree means skb must gone through skb_orphan_partial() */
-	if (nskb->destructor == sock_efree)
+	/* these skbs hold a socket ref but aren't charged to sk_wmem_alloc */
+	if (nskb->destructor == sock_efree ||
+	    nskb->destructor == sock_pfree_ref)
 		return;
 
 	delta = nskb->truesize - skb->truesize;
diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index 62de0919db72..45e3018fb2ae 100644
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -4611,7 +4611,9 @@ union bpf_attr {
  *		**bpf_clone_redirect**\ () or other methods outside of BPF may
  *		interfere with successful delivery to the socket.
  *
- *		This operation is only valid from TC ingress path.
+ *		This operation is valid from TC ingress and egress paths.
+ *		On egress, only full refcounted sockets are accepted.
+ *		Software GSO segmentation after assignment is unsupported.
  *
  *		The *flags* argument must be zero.
  *	Return
@@ -4623,8 +4625,8 @@ union bpf_attr {
  *
  *		**-ENETUNREACH** if the socket is unreachable (wrong netns).
  *
- *		**-EOPNOTSUPP** if the operation is not supported, for example
- *		a call from outside of TC ingress.
+ *		**-EOPNOTSUPP** if the socket is unhashed, or TC egress uses
+ *		a non-full or non-refcounted socket or a decrypted packet.
  *
  * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags)
  *	Description
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 4/8] bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
                   ` (2 preceding siblings ...)
  2026-11-19 14:22 ` [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 15:24   ` sashiko-bot
  2026-11-19 14:22 ` [PATCH bpf-next 5/8] selftests/bpf: Delete assign_reuse namespace when opening it fails Nikolay Aleksandrov
                   ` (3 subsequent siblings)
  7 siblings, 1 reply; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Daniel Borkmann, Nikolay Aleksandrov, Alexei Starovoitov,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, John Fastabend,
	Stanislav Fomichev, David S. Miller, Eric Dumazet, Jakub Kicinski,
	Paolo Abeni, Simon Horman, Kuniyuki Iwashima, Paul Chaignon,
	Alasdair McWilliam, netdev

From: Daniel Borkmann <daniel@iogearbox.net>

Accept full SOCK_RCU_FREE sockets, including listeners, on TC egress,
taking an skb-owned reference. Request and time-wait sockets remain
unsupported. The BPF TPROXY use case needs to assign a listening socket
(e.g. Envoy proxy) to an skb from tc egress. With netkit, the BPF program
runs on the container's egress side and returns NETKIT_PASS, which delivers
the skb to the host via __netif_rx -> backlog.

The fq qdisc discards listener assignments; ordinary loopback also drops
egress assignments. Both can miss the selected proxy even without GSO.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: John Fastabend <john.fastabend@gmail.com>
CC: Stanislav Fomichev <sdf@fomichev.me>
CC: David S. Miller <davem@davemloft.net>
CC: Eric Dumazet <edumazet@kernel.org>
CC: Jakub Kicinski <kuba@kernel.org>
CC: Paolo Abeni <pabeni@redhat.com>
CC: Simon Horman <horms@kernel.org>
CC: Kuniyuki Iwashima <kuniyu@google.com>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>
CC: netdev@vger.kernel.org

 include/uapi/linux/bpf.h       | 5 +++--
 net/core/filter.c              | 3 +--
 tools/include/uapi/linux/bpf.h | 5 +++--
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index 45e3018fb2ae..e8a7ebee305c 100644
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -4612,7 +4612,8 @@ union bpf_attr {
  *		interfere with successful delivery to the socket.
  *
  *		This operation is valid from TC ingress and egress paths.
- *		On egress, only full refcounted sockets are accepted.
+ *		On egress, only full sockets are accepted. Assignment takes an
+ *		skb-owned reference and releases any previous send-side owner.
  *		Software GSO segmentation after assignment is unsupported.
  *
  *		The *flags* argument must be zero.
@@ -4626,7 +4627,7 @@ union bpf_attr {
  *		**-ENETUNREACH** if the socket is unreachable (wrong netns).
  *
  *		**-EOPNOTSUPP** if the socket is unhashed, or TC egress uses
- *		a non-full or non-refcounted socket or a decrypted packet.
+ *		a non-full socket or a decrypted packet.
  *
  * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags)
  *	Description
diff --git a/net/core/filter.c b/net/core/filter.c
index feeb752f7a00..4dea2cc84712 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -8123,8 +8123,7 @@ BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)
 
 	if (!sk || flags != 0)
 		return -EINVAL;
-	if (egress && (!sk_fullsock(sk) || !sk_is_refcounted(sk) ||
-		       skb_is_decrypted(skb)))
+	if (egress && (!sk_fullsock(sk) || skb_is_decrypted(skb)))
 		return -EOPNOTSUPP;
 	refcounted = egress || sk_is_refcounted(sk);
 	if (unlikely(dev_net(skb->dev) != sock_net(sk)))
diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index 45e3018fb2ae..e8a7ebee305c 100644
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -4612,7 +4612,8 @@ union bpf_attr {
  *		interfere with successful delivery to the socket.
  *
  *		This operation is valid from TC ingress and egress paths.
- *		On egress, only full refcounted sockets are accepted.
+ *		On egress, only full sockets are accepted. Assignment takes an
+ *		skb-owned reference and releases any previous send-side owner.
  *		Software GSO segmentation after assignment is unsupported.
  *
  *		The *flags* argument must be zero.
@@ -4626,7 +4627,7 @@ union bpf_attr {
  *		**-ENETUNREACH** if the socket is unreachable (wrong netns).
  *
  *		**-EOPNOTSUPP** if the socket is unhashed, or TC egress uses
- *		a non-full or non-refcounted socket or a decrypted packet.
+ *		a non-full socket or a decrypted packet.
  *
  * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags)
  *	Description
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 5/8] selftests/bpf: Delete assign_reuse namespace when opening it fails
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
                   ` (3 preceding siblings ...)
  2026-11-19 14:22 ` [PATCH bpf-next 4/8] bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 6/8] selftests/bpf: Cover egress socket assignment with reuseport Nikolay Aleksandrov
                   ` (2 subsequent siblings)
  7 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Nikolay Aleksandrov, Alexei Starovoitov, Daniel Borkmann,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, Paul Chaignon, Alasdair McWilliam

Delete the newly created test namespace when open_netns() fails,
instead of returning before cleanup.

Fixes: 22408d58a42c ("selftests/bpf: Test that SO_REUSEPORT can be used with sk_assign helper")
Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>

 tools/testing/selftests/bpf/prog_tests/assign_reuse.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/bpf/prog_tests/assign_reuse.c b/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
index 989ee4d9785b..23ed1290957b 100644
--- a/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
+++ b/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
@@ -180,7 +180,7 @@ void test_assign_reuse(void)
 
 	tok = open_netns(NS_TEST);
 	if (!ASSERT_OK_PTR(tok, "netns token"))
-		return;
+		goto cleanup;
 
 	if (test__start_subtest("tcpv4"))
 		run_assign_reuse(AF_INET, SOCK_STREAM, "127.0.0.1", PORT);
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 6/8] selftests/bpf: Cover egress socket assignment with reuseport
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
                   ` (4 preceding siblings ...)
  2026-11-19 14:22 ` [PATCH bpf-next 5/8] selftests/bpf: Delete assign_reuse namespace when opening it fails Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 7/8] selftests/bpf: Exercise netkit socket assignment to a host proxy Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 8/8] selftests/bpf: Check assigned socket lifetime across queues and drops Nikolay Aleksandrov
  7 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Nikolay Aleksandrov, Alexei Starovoitov, Daniel Borkmann,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, Paul Chaignon, Alasdair McWilliam

Cover IPv4/IPv6 TCP and UDP assignment on TC egress with reuseport accept
and drop verdicts, selecting the original or another socket.

Track exchanges by distinct source ports so delayed SYNs retain their
selection and accounting. After detaching TC, wait for counted reuseport
completions and check every exchange. Publish completion with a fetching
64-bit atomic so arm64 observes prior result updates.

Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>

 .../selftests/bpf/prog_tests/assign_reuse.c   | 266 ++++++++++++++++--
 .../selftests/bpf/progs/test_assign_reuse.c   | 129 ++++++++-
 2 files changed, 366 insertions(+), 29 deletions(-)

diff --git a/tools/testing/selftests/bpf/prog_tests/assign_reuse.c b/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
index 23ed1290957b..7b19193ed3d7 100644
--- a/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
+++ b/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
@@ -2,6 +2,7 @@
 /* Copyright (c) 2023 Isovalent */
 #include <uapi/linux/if_link.h>
 #include <test_progs.h>
+#include <stdint.h>
 
 #include <netinet/tcp.h>
 #include <netinet/udp.h>
@@ -12,6 +13,38 @@
 #define NS_TEST "assign_reuse"
 #define LOOPBACK 1
 #define PORT 4443
+#define CLIENT_PORT_MIN 32768
+#define TEST_ITERATIONS 8
+#define IO_TIMEOUT_MS 100
+#define POLL_RETRIES 5000
+#define POLL_INTERVAL_US 1000
+#define NR_EXCHANGES \
+	ARRAY_SIZE(((struct test_assign_reuse__bss *)0)->exchanges)
+
+struct reuse_client {
+	struct test_assign_reuse *skel;
+	__u32 slot;
+	int held_fd;
+};
+
+static bool setup_family(int family)
+{
+	int fd, ret;
+
+	fd = socket(family, SOCK_DGRAM, 0);
+	if (fd < 0 && errno == EAFNOSUPPORT) {
+		printf("SKIP: address family %d is unavailable\n", family);
+		test__skip();
+		return false;
+	}
+	if (!ASSERT_GE(fd, 0, "family_probe"))
+		return false;
+	close(fd);
+	if (family != AF_INET6)
+		return true;
+	ret = write_sysctl("/proc/sys/net/ipv6/conf/all/disable_ipv6", "0");
+	return ASSERT_OK(ret, "enable_ipv6");
+}
 
 static int attach_reuseport(int sock_fd, int prog_fd)
 {
@@ -32,14 +65,15 @@ static __u64 cookie(int fd)
 	return cookie;
 }
 
-static int echo_test_udp(int fd_sv)
+static int echo_test_udp_opts(int fd_sv,
+			      const struct network_helper_opts *opts)
 {
 	struct sockaddr_storage addr = {};
 	socklen_t len = sizeof(addr);
-	char buff[1] = {};
 	int fd_cl = -1, ret;
+	char buff[1] = {};
 
-	fd_cl = connect_to_fd(fd_sv, 100);
+	fd_cl = connect_to_fd_opts(fd_sv, opts);
 	ASSERT_GT(fd_cl, 0, "create_client");
 	ASSERT_EQ(getsockname(fd_cl, (void *)&addr, &len), 0, "getsockname");
 
@@ -58,12 +92,20 @@ static int echo_test_udp(int fd_sv)
 	return 0;
 }
 
-static int echo_test_tcp(int fd_sv)
+static int echo_test_udp(int fd_sv)
+{
+	struct network_helper_opts opts = { .timeout_ms = IO_TIMEOUT_MS };
+
+	return echo_test_udp_opts(fd_sv, &opts);
+}
+
+static int echo_test_tcp_opts(int fd_sv,
+			      const struct network_helper_opts *opts)
 {
-	char buff[1] = {};
 	int fd_cl = -1, fd_sv_cl = -1;
+	char buff[1] = {};
 
-	fd_cl = connect_to_fd(fd_sv, 100);
+	fd_cl = connect_to_fd_opts(fd_sv, opts);
 	if (fd_cl < 0)
 		return errno;
 
@@ -79,8 +121,124 @@ static int echo_test_tcp(int fd_sv)
 	return 0;
 }
 
-void run_assign_reuse(int family, int sotype, const char *ip, __u16 port)
+static int echo_test_tcp(int fd_sv)
 {
+	struct network_helper_opts opts = { .timeout_ms = IO_TIMEOUT_MS };
+
+	return echo_test_tcp_opts(fd_sv, &opts);
+}
+
+static int prepare_reuse_client(int fd, void *arg)
+{
+	struct sockaddr_storage addr = {};
+	struct reuse_client *client = arg;
+	socklen_t len = sizeof(addr);
+	int port, ret, i;
+
+	if (getsockname(fd, (void *)&addr, &len))
+		return -1;
+	ret = make_sockaddr(addr.ss_family, addr.ss_family == AF_INET ?
+			    "127.0.0.1" : "::1", 0, &addr, &len);
+	if (ret)
+		return -1;
+	for (port = CLIENT_PORT_MIN; port <= UINT16_MAX; port++) {
+		for (i = 0; i < client->slot; i++) {
+			if (client->skel->bss->exchanges[i].source_port ==
+			    htons(port))
+				break;
+		}
+		if (i < client->slot)
+			continue;
+		if (addr.ss_family == AF_INET)
+			((struct sockaddr_in *)&addr)->sin_port = htons(port);
+		else
+			((struct sockaddr_in6 *)&addr)->sin6_port = htons(port);
+		ret = bind(fd, (void *)&addr, len);
+		if (!ret)
+			break;
+		if (errno != EADDRINUSE)
+			return -1;
+	}
+	if (port > UINT16_MAX)
+		return -1;
+	client->held_fd = dup(fd);
+	if (client->held_fd < 0)
+		return -1;
+	__atomic_store_n(&client->skel->bss->exchanges[client->slot].source_port,
+			 htons(port), __ATOMIC_RELEASE);
+	return 0;
+}
+
+static bool run_reuse_exchange(struct test_assign_reuse *skel, int fd,
+			       int sotype, __u32 index, bool drop,
+			       struct reuse_client *client, __u32 slot,
+			       __u64 expected_cookie)
+{
+	struct network_helper_opts opts = {
+		.timeout_ms = IO_TIMEOUT_MS,
+		.post_socket_cb = prepare_reuse_client,
+		.cb_opts = client,
+	};
+	int expected, ret;
+
+	client->skel = skel;
+	client->slot = slot;
+	skel->bss->exchanges[slot].expected_cookie = expected_cookie;
+	skel->bss->exchanges[slot].index = index;
+	skel->bss->exchanges[slot].drop = drop;
+	if (sotype == SOCK_STREAM) {
+		expected = drop ? ECONNREFUSED : 0;
+		ret = echo_test_tcp_opts(fd, &opts);
+	} else {
+		expected = drop ? EAGAIN : 0;
+		ret = echo_test_udp_opts(fd, &opts);
+	}
+	return ASSERT_EQ(ret, expected, "exchange_result");
+}
+
+static void check_reuse_exchanges(struct test_assign_reuse *skel)
+{
+	typeof(skel->bss->exchanges[0]) *exchange;
+	bool complete = false;
+	int i, j;
+
+	for (i = 0; i < POLL_RETRIES; i++) {
+		complete = true;
+		for (j = 0; j < ARRAY_SIZE(skel->bss->exchanges); j++) {
+			exchange = &skel->bss->exchanges[j];
+			if (!exchange->source_port)
+				continue;
+			if (__atomic_load_n(&exchange->reuse_calls,
+					    __ATOMIC_ACQUIRE) !=
+			    exchange->assign_calls - exchange->assign_errors)
+				complete = false;
+		}
+		if (complete)
+			break;
+		usleep(POLL_INTERVAL_US);
+	}
+	ASSERT_TRUE(complete, "reuseport_drained");
+	for (i = 0; i < ARRAY_SIZE(skel->bss->exchanges); i++) {
+		exchange = &skel->bss->exchanges[i];
+		if (!exchange->source_port)
+			continue;
+		ASSERT_GT(exchange->assign_calls, 0, "final_assign_calls");
+		ASSERT_EQ(exchange->reuse_calls, exchange->assign_calls,
+			  "final_reuse_calls");
+		ASSERT_EQ(exchange->assign_errors, 0, "final_assign_errors");
+		ASSERT_EQ(exchange->select_errors, 0, "final_select_errors");
+		ASSERT_EQ(exchange->cookie_errors, 0, "final_cookie_errors");
+		ASSERT_EQ(exchange->sk_cookie, exchange->expected_cookie,
+			  "final_assigned_socket_cookie");
+	}
+}
+
+static void run_assign_reuse(int family, int sotype, const char *ip, __u16 port,
+			     bool egress)
+{
+	bool hook_created = false, tc_attached = false;
+	int ret, fd_tc, fd_accept, fd_drop, fd_map;
+	struct reuse_client clients[NR_EXCHANGES];
 	DECLARE_LIBBPF_OPTS(bpf_tc_hook, tc_hook,
 		.ifindex = LOOPBACK,
 		.attach_point = BPF_TC_INGRESS,
@@ -89,18 +247,40 @@ void run_assign_reuse(int family, int sotype, const char *ip, __u16 port)
 		.handle = 1,
 		.priority = 1,
 	);
-	bool hook_created = false, tc_attached = false;
-	int ret, fd_tc, fd_accept, fd_drop, fd_map;
+	struct test_assign_reuse *skel = NULL;
+	int nr_listens = egress ? 2 : 1;
+	const int zero = 0;
 	int *fd_sv = NULL;
+	__u32 slot = 0;
 	__u64 fd_val;
-	struct test_assign_reuse *skel;
-	const int zero = 0;
+	int i, j;
 
+	for (i = 0; i < ARRAY_SIZE(clients); i++)
+		clients[i].held_fd = -1;
+	if (!setup_family(family))
+		goto cleanup;
 	skel = test_assign_reuse__open();
 	if (!ASSERT_OK_PTR(skel, "skel_open"))
 		goto cleanup;
 
 	skel->rodata->dest_port = port;
+	skel->rodata->select_sock = egress;
+	if (egress) {
+		ret = kern_sync_rcu();
+		if (ret && (errno == ENOSYS || errno == EINVAL)) {
+			printf("SKIP: RCU synchronization is unavailable\n");
+			test__skip();
+			goto cleanup;
+		}
+		if (!ASSERT_OK(ret, "sync_rcu_probe"))
+			goto cleanup;
+		tc_hook.attach_point = BPF_TC_EGRESS;
+		if (!ASSERT_OK(write_sysctl("/proc/sys/net/ipv4/conf/lo/accept_local", "1"),
+			       "accept_local") ||
+		    !ASSERT_OK(write_sysctl("/proc/sys/net/ipv4/conf/lo/route_localnet", "1"),
+			       "route_localnet"))
+			goto cleanup;
+	}
 
 	ret = test_assign_reuse__load(skel);
 	if (!ASSERT_OK(ret, "skel_load"))
@@ -113,7 +293,8 @@ void run_assign_reuse(int family, int sotype, const char *ip, __u16 port)
 	fd_drop = bpf_program__fd(skel->progs.reuse_drop);
 	fd_map = bpf_map__fd(skel->maps.sk_map);
 
-	fd_sv = start_reuseport_server(family, sotype, ip, port, 100, 1);
+	fd_sv = start_reuseport_server(family, sotype, ip, port, IO_TIMEOUT_MS,
+				       nr_listens);
 	if (!ASSERT_NEQ(fd_sv, NULL, "start_reuseport_server"))
 		goto cleanup;
 
@@ -125,6 +306,12 @@ void run_assign_reuse(int family, int sotype, const char *ip, __u16 port)
 	ret = bpf_map_update_elem(fd_map, &zero, &fd_val, BPF_NOEXIST);
 	if (!ASSERT_OK(ret, "bpf_sk_map"))
 		goto cleanup;
+	for (i = 1; i < nr_listens; i++) {
+		fd_val = fd_sv[i];
+		ret = bpf_map_update_elem(fd_map, &i, &fd_val, BPF_NOEXIST);
+		if (!ASSERT_OK(ret, "sk_map_update"))
+			goto cleanup;
+	}
 
 	ret = bpf_tc_hook_create(&tc_hook);
 	if (ret == 0)
@@ -139,11 +326,37 @@ void run_assign_reuse(int family, int sotype, const char *ip, __u16 port)
 		goto cleanup;
 	tc_attached = true;
 
+	if (egress) {
+		if (!run_reuse_exchange(skel, fd_sv[0], sotype, 0, true,
+					&clients[slot], slot, cookie(fd_sv[0])))
+			goto cleanup;
+		slot++;
+		if (!ASSERT_OK(attach_reuseport(*fd_sv, fd_accept),
+			       "attach_reuseport(accept)"))
+			goto cleanup;
+		if (!run_reuse_exchange(skel, fd_sv[0], sotype, 0, false,
+					&clients[slot], slot, cookie(fd_sv[0])))
+			goto cleanup;
+		slot++;
+		for (i = 0; i < nr_listens; i++) {
+			for (j = 0; j < TEST_ITERATIONS; j++) {
+				if (!run_reuse_exchange(skel, fd_sv[i], sotype,
+							i, false, &clients[slot],
+							slot, cookie(fd_sv[0])))
+					goto cleanup;
+				slot++;
+			}
+		}
+		goto cleanup;
+	}
+
 	if (sotype == SOCK_STREAM)
 		ASSERT_EQ(echo_test_tcp(*fd_sv), ECONNREFUSED, "drop_tcp");
 	else
 		ASSERT_EQ(echo_test_udp(*fd_sv), EAGAIN, "drop_udp");
 	ASSERT_EQ(skel->bss->reuseport_executed, 1, "program executed once");
+	ASSERT_EQ(skel->bss->assign_calls, 1, "drop_assign_calls");
+	ASSERT_EQ(skel->bss->assign_errors, 0, "drop_assign_errors");
 
 	skel->bss->sk_cookie_seen = 0;
 	skel->bss->reuseport_executed = 0;
@@ -157,18 +370,25 @@ void run_assign_reuse(int family, int sotype, const char *ip, __u16 port)
 	ASSERT_EQ(skel->bss->sk_cookie_seen, cookie(*fd_sv),
 		  "cookie_mismatch");
 	ASSERT_EQ(skel->bss->reuseport_executed, 1, "program executed once");
+
 cleanup:
+	for (i = 0; i < ARRAY_SIZE(clients); i++) {
+		if (clients[i].held_fd >= 0)
+			close(clients[i].held_fd);
+	}
 	if (tc_attached) {
 		tc_opts.flags = tc_opts.prog_fd = tc_opts.prog_id = 0;
 		ret = bpf_tc_detach(&tc_hook, &tc_opts);
-		ASSERT_OK(ret, "bpf_tc_detach");
+		if (ASSERT_OK(ret, "bpf_tc_detach") && egress &&
+		    ASSERT_OK(kern_sync_rcu(), "sync_assignments"))
+			check_reuse_exchanges(skel);
 	}
 	if (hook_created) {
 		tc_hook.attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS;
 		bpf_tc_hook_destroy(&tc_hook);
 	}
 	test_assign_reuse__destroy(skel);
-	free_fds(fd_sv, 1);
+	free_fds(fd_sv, nr_listens);
 }
 
 void test_assign_reuse(void)
@@ -179,17 +399,25 @@ void test_assign_reuse(void)
 	SYS(cleanup, "ip -net %s link set dev lo up", NS_TEST);
 
 	tok = open_netns(NS_TEST);
-	if (!ASSERT_OK_PTR(tok, "netns token"))
+	if (!ASSERT_NEQ(tok, NULL, "netns token"))
 		goto cleanup;
 
 	if (test__start_subtest("tcpv4"))
-		run_assign_reuse(AF_INET, SOCK_STREAM, "127.0.0.1", PORT);
+		run_assign_reuse(AF_INET, SOCK_STREAM, "127.0.0.1", PORT, false);
 	if (test__start_subtest("tcpv6"))
-		run_assign_reuse(AF_INET6, SOCK_STREAM, "::1", PORT);
+		run_assign_reuse(AF_INET6, SOCK_STREAM, "::1", PORT, false);
 	if (test__start_subtest("udpv4"))
-		run_assign_reuse(AF_INET, SOCK_DGRAM, "127.0.0.1", PORT);
+		run_assign_reuse(AF_INET, SOCK_DGRAM, "127.0.0.1", PORT, false);
 	if (test__start_subtest("udpv6"))
-		run_assign_reuse(AF_INET6, SOCK_DGRAM, "::1", PORT);
+		run_assign_reuse(AF_INET6, SOCK_DGRAM, "::1", PORT, false);
+	if (test__start_subtest("tcpv4_egress"))
+		run_assign_reuse(AF_INET, SOCK_STREAM, "127.0.0.1", PORT, true);
+	if (test__start_subtest("tcpv6_egress"))
+		run_assign_reuse(AF_INET6, SOCK_STREAM, "::1", PORT, true);
+	if (test__start_subtest("udpv4_egress"))
+		run_assign_reuse(AF_INET, SOCK_DGRAM, "127.0.0.1", PORT, true);
+	if (test__start_subtest("udpv6_egress"))
+		run_assign_reuse(AF_INET6, SOCK_DGRAM, "::1", PORT, true);
 
 cleanup:
 	close_netns(tok);
diff --git a/tools/testing/selftests/bpf/progs/test_assign_reuse.c b/tools/testing/selftests/bpf/progs/test_assign_reuse.c
index 4f2e2321ea06..9098fe4707ff 100644
--- a/tools/testing/selftests/bpf/progs/test_assign_reuse.c
+++ b/tools/testing/selftests/bpf/progs/test_assign_reuse.c
@@ -11,6 +11,9 @@
 #include <bpf/bpf_endian.h>
 #include <bpf/bpf_helpers.h>
 #include <linux/pkt_cls.h>
+#include "bpf_misc.h"
+
+#define NR_EXCHANGES 18
 
 char LICENSE[] SEC("license") = "GPL";
 
@@ -22,17 +25,92 @@ union {
 } headers;
 
 const volatile __u16 dest_port;
+const volatile bool select_sock;
+__u64 assign_calls;
+__u64 assign_errors;
+
+struct {
+	__u64 expected_cookie;
+	__u64 sk_cookie;
+	__u64 reuse_calls;
+	__u32 assign_calls;
+	__u32 assign_errors;
+	__u32 select_errors;
+	__u32 cookie_errors;
+	__u32 index;
+	__u32 drop;
+	__u16 source_port;
+} exchanges[NR_EXCHANGES];
 
 struct {
 	__uint(type, BPF_MAP_TYPE_SOCKMAP);
-	__uint(max_entries, 1);
+	__uint(max_entries, 2);
 	__type(key, __u32);
 	__type(value, __u64);
 } sk_map SEC(".maps");
 
+static __always_inline typeof(exchanges[0]) *find_exchange(__u16 source)
+{
+	int i;
+
+#pragma unroll
+	for (i = 0; i < ARRAY_SIZE(exchanges); i++) {
+		if (source && exchanges[i].source_port == source)
+			return &exchanges[i];
+	}
+	return NULL;
+}
+
+static __always_inline int select_exchange(struct sk_reuseport_md *ctx)
+{
+	void *data_end = (void *)(long)ctx->data_end;
+	void *data = (void *)(long)ctx->data;
+	typeof(exchanges[0]) *exchange;
+	struct tcphdr *th = data;
+	struct udphdr *uh = data;
+	__u64 increment = 1;
+	int ret = SK_DROP;
+	__u16 source;
+	__u64 cookie;
+	__u32 index;
+
+	if (ctx->ip_protocol == IPPROTO_TCP) {
+		if ((void *)(th + 1) > data_end || !th->syn || th->ack ||
+		    th->dest != bpf_htons(dest_port))
+			return SK_DROP;
+		source = th->source;
+	} else if (ctx->ip_protocol == IPPROTO_UDP) {
+		if ((void *)(uh + 1) > data_end ||
+		    uh->dest != bpf_htons(dest_port))
+			return SK_DROP;
+		source = uh->source;
+	} else {
+		return SK_DROP;
+	}
+	exchange = find_exchange(source);
+	if (!exchange)
+		return SK_DROP;
+	cookie = bpf_get_socket_cookie(ctx->sk);
+	exchange->sk_cookie = cookie;
+	if (cookie != exchange->expected_cookie)
+		__sync_fetch_and_add(&exchange->cookie_errors, 1);
+	if (!exchange->drop) {
+		index = exchange->index;
+		if (bpf_sk_select_reuseport(ctx, &sk_map, &index, 0))
+			__sync_fetch_and_add(&exchange->select_errors, 1);
+		else
+			ret = SK_PASS;
+	}
+	asm volatile("%0 = atomic_fetch_add((u64 *)(%1 + 0), %0);"
+		     : "+r"(increment) : "r"(&exchange->reuse_calls) : "memory");
+	return ret;
+}
+
 SEC("sk_reuseport")
 int reuse_accept(struct sk_reuseport_md *ctx)
 {
+	if (select_sock)
+		return select_exchange(ctx);
 	reuseport_executed++;
 
 	if (ctx->ip_protocol == IPPROTO_TCP) {
@@ -58,49 +136,80 @@ int reuse_accept(struct sk_reuseport_md *ctx)
 SEC("sk_reuseport")
 int reuse_drop(struct sk_reuseport_md *ctx)
 {
+	if (select_sock)
+		return select_exchange(ctx);
 	reuseport_executed++;
 	sk_cookie_seen = 0;
 	return SK_DROP;
 }
 
 static int
-assign_sk(struct __sk_buff *skb)
+assign_sk(struct __sk_buff *skb, typeof(exchanges[0]) *exchange)
 {
-	int zero = 0, ret = 0;
 	struct bpf_sock *sk;
+	int zero = 0, ret;
 
 	sk = bpf_map_lookup_elem(&sk_map, &zero);
 	if (!sk)
 		return TC_ACT_SHOT;
 	ret = bpf_sk_assign(skb, sk, 0);
+	if (select_sock) {
+		__sync_fetch_and_add(&exchange->assign_calls, 1);
+		if (ret)
+			__sync_fetch_and_add(&exchange->assign_errors, 1);
+	} else {
+		__sync_fetch_and_add(&assign_calls, 1);
+		if (ret)
+			__sync_fetch_and_add(&assign_errors, 1);
+	}
 	bpf_sk_release(sk);
-	return ret ? TC_ACT_SHOT : TC_ACT_OK;
+	if (ret)
+		return TC_ACT_SHOT;
+	if (select_sock)
+		return bpf_redirect(skb->ifindex, BPF_F_INGRESS);
+	return TC_ACT_OK;
 }
 
-static bool
+static int
 maybe_assign_tcp(struct __sk_buff *skb, struct tcphdr *th)
 {
+	typeof(exchanges[0]) *exchange = NULL;
+
 	if (th + 1 > (void *)(long)(skb->data_end))
 		return TC_ACT_SHOT;
 
 	if (!th->syn || th->ack || th->dest != bpf_htons(dest_port))
 		return TC_ACT_OK;
 
-	__builtin_memcpy(&headers.tcp, th, sizeof(headers.tcp));
-	return assign_sk(skb);
+	if (select_sock) {
+		exchange = find_exchange(th->source);
+		if (!exchange)
+			return TC_ACT_OK;
+	} else {
+		__builtin_memcpy(&headers.tcp, th, sizeof(headers.tcp));
+	}
+	return assign_sk(skb, exchange);
 }
 
-static bool
+static int
 maybe_assign_udp(struct __sk_buff *skb, struct udphdr *uh)
 {
+	typeof(exchanges[0]) *exchange = NULL;
+
 	if (uh + 1 > (void *)(long)(skb->data_end))
 		return TC_ACT_SHOT;
 
 	if (uh->dest != bpf_htons(dest_port))
 		return TC_ACT_OK;
 
-	__builtin_memcpy(&headers.udp, uh, sizeof(headers.udp));
-	return assign_sk(skb);
+	if (select_sock) {
+		exchange = find_exchange(uh->source);
+		if (!exchange)
+			return TC_ACT_OK;
+	} else {
+		__builtin_memcpy(&headers.udp, uh, sizeof(headers.udp));
+	}
+	return assign_sk(skb, exchange);
 }
 
 SEC("tc")
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 7/8] selftests/bpf: Exercise netkit socket assignment to a host proxy
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
                   ` (5 preceding siblings ...)
  2026-11-19 14:22 ` [PATCH bpf-next 6/8] selftests/bpf: Cover egress socket assignment with reuseport Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  2026-11-19 14:22 ` [PATCH bpf-next 8/8] selftests/bpf: Check assigned socket lifetime across queues and drops Nikolay Aleksandrov
  7 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Nikolay Aleksandrov, Alexei Starovoitov, Daniel Borkmann,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, Paul Chaignon, Alasdair McWilliam

Test IPv4/IPv6 TCP assignment from a netkit peer to transparent host
listeners, preserving original destinations and bidirectional payloads.
Cover established sockets and request/time-wait rejection.

Honor rtnetlink error suppression to skip unavailable netkit support.
Detach before final counter checks while the listener remains open.

Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>

 tools/testing/selftests/bpf/netlink_helpers.c |   3 +-
 .../bpf/prog_tests/sk_assign_netkit.c         | 304 ++++++++++++++++++
 .../selftests/bpf/progs/sk_assign_netkit.c    | 137 ++++++++
 3 files changed, 443 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
 create mode 100644 tools/testing/selftests/bpf/progs/sk_assign_netkit.c

diff --git a/tools/testing/selftests/bpf/netlink_helpers.c b/tools/testing/selftests/bpf/netlink_helpers.c
index caf36eb1d032..c9488ba5606e 100644
--- a/tools/testing/selftests/bpf/netlink_helpers.c
+++ b/tools/testing/selftests/bpf/netlink_helpers.c
@@ -276,7 +276,8 @@ static int __rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n,
 int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n,
 	      struct nlmsghdr **answer)
 {
-	return __rtnl_talk(rtnl, n, answer, true, NULL);
+	return __rtnl_talk(rtnl, n, answer,
+			   !(rtnl->flags & RTNL_HANDLE_F_SUPPRESS_NLERR), NULL);
 }
 
 int addattr(struct nlmsghdr *n, int maxlen, int type)
diff --git a/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c b/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
new file mode 100644
index 000000000000..eb2dd03b923e
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
@@ -0,0 +1,304 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <net/if.h>
+#include <netinet/tcp.h>
+#include <uapi/linux/if_link.h>
+#include <test_progs.h>
+#include "netlink_helpers.h"
+#include "network_helpers.h"
+#include "sk_assign_netkit.skel.h"
+
+#define NS_HOST "sk_assign_host"
+#define NS_POD "sk_assign_pod"
+#define HOST_DEV "nk_host"
+#define POD_DEV "nk_pod"
+#define DEST_PORT 18080
+#define PROXY_PORT 15001
+#define TEST_DATA "test"
+#define TEST_ITERATIONS 8
+#define IO_TIMEOUT_MS 1000
+#define POLL_RETRIES 5000
+#define POLL_INTERVAL_US 1000
+
+struct netkit_request {
+	struct nlmsghdr n;
+	struct ifinfomsg i;
+	char buf[1024];
+};
+
+static int create_netkit(void)
+{
+	struct rtattr *linkinfo, *data, *peer_info;
+	struct rtnl_handle rth = { .fd = -1 };
+	struct netkit_request req = {};
+	int err;
+
+	err = rtnl_open(&rth, 0);
+	if (err)
+		return err;
+	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
+	req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
+	req.n.nlmsg_type = RTM_NEWLINK;
+	req.i.ifi_family = AF_UNSPEC;
+	addattrstrz(&req.n, sizeof(req), IFLA_IFNAME, HOST_DEV);
+	linkinfo = addattr_nest(&req.n, sizeof(req), IFLA_LINKINFO);
+	addattrstrz(&req.n, sizeof(req), IFLA_INFO_KIND, "netkit");
+	data = addattr_nest(&req.n, sizeof(req), IFLA_INFO_DATA);
+	addattr32(&req.n, sizeof(req), IFLA_NETKIT_MODE, NETKIT_L2);
+	peer_info = addattr_nest(&req.n, sizeof(req), IFLA_NETKIT_PEER_INFO);
+	req.n.nlmsg_len += sizeof(struct ifinfomsg);
+	addattrstrz(&req.n, sizeof(req), IFLA_IFNAME, POD_DEV);
+	addattr_nest_end(&req.n, peer_info);
+	addattr_nest_end(&req.n, data);
+	addattr_nest_end(&req.n, linkinfo);
+	rth.flags |= RTNL_HANDLE_F_SUPPRESS_NLERR;
+	err = rtnl_talk(&rth, &req.n, NULL);
+	if (err)
+		err = -errno;
+	rtnl_close(&rth);
+	return err;
+}
+
+static int transparent_socket(int fd, void *opts)
+{
+	int family = *(int *)opts;
+	int one = 1;
+
+	if (family == AF_INET6) {
+		if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one)))
+			return -1;
+		return setsockopt(fd, IPPROTO_IPV6, IPV6_TRANSPARENT, &one,
+				  sizeof(one));
+	}
+	return setsockopt(fd, SOL_IP, IP_TRANSPARENT, &one, sizeof(one));
+}
+
+static void check_timewait(struct sk_assign_netkit *skel, int family,
+			   int accepted, int client)
+{
+	struct __sk_buff ctx = { .ifindex = if_nametoindex(HOST_DEV) };
+	DECLARE_LIBBPF_OPTS(bpf_test_run_opts, opts,
+		.data_in = &pkt_v4,
+		.data_size_in = sizeof(pkt_v4),
+		.ctx_in = &ctx,
+		.ctx_size_in = sizeof(ctx),
+	);
+	struct sockaddr_storage local, peer;
+	socklen_t len = sizeof(local);
+	struct sockaddr_in6 *l6, *p6;
+	struct sockaddr_in *l4, *p4;
+	int i, fd;
+	char buf;
+
+	if (!ASSERT_OK(getsockname(accepted, (void *)&local, &len),
+		       "timewait_local"))
+		return;
+	len = sizeof(peer);
+	if (!ASSERT_OK(getpeername(accepted, (void *)&peer, &len),
+		       "timewait_peer"))
+		return;
+	if (family == AF_INET) {
+		l4 = (void *)&local;
+		p4 = (void *)&peer;
+		skel->bss->probe_tuple.ipv4.saddr = p4->sin_addr.s_addr;
+		skel->bss->probe_tuple.ipv4.daddr = l4->sin_addr.s_addr;
+		skel->bss->probe_tuple.ipv4.sport = p4->sin_port;
+		skel->bss->probe_tuple.ipv4.dport = l4->sin_port;
+		skel->bss->probe_len = sizeof(skel->bss->probe_tuple.ipv4);
+	} else {
+		l6 = (void *)&local;
+		p6 = (void *)&peer;
+		memcpy(skel->bss->probe_tuple.ipv6.saddr, &p6->sin6_addr,
+		       sizeof(p6->sin6_addr));
+		memcpy(skel->bss->probe_tuple.ipv6.daddr, &l6->sin6_addr,
+		       sizeof(l6->sin6_addr));
+		skel->bss->probe_tuple.ipv6.sport = p6->sin6_port;
+		skel->bss->probe_tuple.ipv6.dport = l6->sin6_port;
+		skel->bss->probe_len = sizeof(skel->bss->probe_tuple.ipv6);
+	}
+	if (!ASSERT_OK(shutdown(accepted, SHUT_WR), "server_shutdown") ||
+	    !ASSERT_EQ(recv(client, &buf, 1, 0), 0, "client_eof") ||
+	    !ASSERT_OK(shutdown(client, SHUT_WR), "client_shutdown") ||
+	    !ASSERT_EQ(recv(accepted, &buf, 1, 0), 0, "server_eof"))
+		return;
+	fd = bpf_program__fd(skel->progs.probe_timewait);
+	for (i = 0; i < POLL_RETRIES; i++) {
+		if (!ASSERT_OK(bpf_prog_test_run_opts(fd, &opts), "probe_timewait"))
+			return;
+		if (skel->bss->probe_state == BPF_TCP_TIME_WAIT)
+			break;
+		usleep(POLL_INTERVAL_US);
+	}
+	ASSERT_EQ(skel->bss->probe_state, BPF_TCP_TIME_WAIT, "timewait_found");
+	ASSERT_EQ(skel->bss->probe_result, -EOPNOTSUPP, "timewait_rejected");
+}
+
+static int enable_netns_ipv6(const char *name)
+{
+	struct nstoken *token;
+	int err;
+
+	token = open_netns(name);
+	if (!token)
+		return -1;
+	err = write_sysctl("/proc/sys/net/ipv6/conf/all/disable_ipv6", "0");
+	if (!err)
+		err = write_sysctl("/proc/sys/net/ipv6/conf/default/disable_ipv6",
+				   "0");
+	close_netns(token);
+	return err;
+}
+
+static void run_netkit(int family)
+{
+	const char *dest = family == AF_INET ? "198.18.0.99" : "2001:db8:99::99";
+	struct network_helper_opts client_opts = { .timeout_ms = IO_TIMEOUT_MS };
+	const char *bind_addr = family == AF_INET ? "0.0.0.0" : "::";
+	int server = -1, client = -1, accepted = -1;
+	struct netns_obj *host = NULL, *pod = NULL;
+	struct sockaddr_storage expected, actual;
+	struct sk_assign_netkit *skel = NULL;
+	struct network_helper_opts opts = {
+		.timeout_ms = IO_TIMEOUT_MS,
+		.post_socket_cb = transparent_socket,
+		.cb_opts = &family,
+	};
+	char buf[sizeof(TEST_DATA) - 1];
+	struct nstoken *pod_tok = NULL;
+	struct bpf_link *link = NULL;
+	socklen_t len, actual_len;
+	int i, err;
+
+	err = socket(family, SOCK_STREAM, 0);
+	if (err < 0 && errno == EAFNOSUPPORT) {
+		printf("SKIP: address family %d is unavailable\n", family);
+		test__skip();
+		return;
+	}
+	if (!ASSERT_GE(err, 0, "family_probe"))
+		return;
+	close(err);
+	host = netns_new(NS_HOST, true);
+	if (!ASSERT_NEQ(host, NULL, "host_netns"))
+		goto cleanup;
+	pod = netns_new(NS_POD, false);
+	if (!ASSERT_NEQ(pod, NULL, "pod_netns"))
+		goto cleanup;
+	if (family == AF_INET6 &&
+	    (!ASSERT_OK(enable_netns_ipv6(NS_HOST), "host_ipv6") ||
+	     !ASSERT_OK(enable_netns_ipv6(NS_POD), "pod_ipv6")))
+		goto cleanup;
+	err = create_netkit();
+	if (err == -EOPNOTSUPP) {
+		printf("SKIP: netkit is unavailable\n");
+		test__skip();
+		goto cleanup;
+	}
+	if (!ASSERT_OK(err, "create_netkit"))
+		goto cleanup;
+	SYS(cleanup, "ip link set %s netns %s", POD_DEV, NS_POD);
+	SYS(cleanup, "ip link set %s up", HOST_DEV);
+	SYS(cleanup, "ip -n %s link set %s up", NS_POD, POD_DEV);
+	if (family == AF_INET) {
+		SYS(cleanup, "ip addr add 10.88.0.1/24 dev %s", HOST_DEV);
+		SYS(cleanup, "ip -n %s addr add 10.88.0.2/24 dev %s", NS_POD, POD_DEV);
+		SYS(cleanup, "ip -n %s route add default via 10.88.0.1", NS_POD);
+		SYS(cleanup, "ip route add local 198.18.0.99/32 dev lo");
+		if (!ASSERT_OK(write_sysctl("/proc/sys/net/ipv4/conf/all/rp_filter", "0"),
+			       "rp_filter_all") ||
+		    !ASSERT_OK(write_sysctl("/proc/sys/net/ipv4/conf/" HOST_DEV
+				   "/rp_filter", "0"),
+			       "rp_filter_host"))
+			goto cleanup;
+	} else {
+		SYS(cleanup, "ip -6 addr add fd88::1/64 dev %s nodad", HOST_DEV);
+		SYS(cleanup, "ip -n %s -6 addr add fd88::2/64 dev %s nodad", NS_POD, POD_DEV);
+		SYS(cleanup, "ip -n %s -6 route add default via fd88::1", NS_POD);
+		SYS(cleanup, "ip -6 route add local 2001:db8:99::99/128 dev lo");
+	}
+
+	server = start_server_str(family, SOCK_STREAM, bind_addr, PROXY_PORT, &opts);
+	if (!ASSERT_GE(server, 0, "start_server"))
+		goto cleanup;
+	skel = sk_assign_netkit__open();
+	if (!ASSERT_OK_PTR(skel, "skel_open"))
+		goto cleanup;
+	skel->rodata->dest_port = DEST_PORT;
+	skel->rodata->proxy_port = PROXY_PORT;
+	if (!ASSERT_OK(sk_assign_netkit__load(skel), "skel_load"))
+		goto cleanup;
+	link = bpf_program__attach_netkit(skel->progs.assign_socket,
+					  if_nametoindex(HOST_DEV), NULL);
+	if (!ASSERT_OK_PTR(link, "attach_netkit"))
+		goto cleanup;
+	if (!ASSERT_OK(make_sockaddr(family, dest, DEST_PORT, &expected, &len),
+		       "make_sockaddr"))
+		goto cleanup;
+
+	for (i = 0; i < TEST_ITERATIONS; i++) {
+		pod_tok = open_netns(NS_POD);
+		if (!ASSERT_NEQ(pod_tok, NULL, "open_pod"))
+			goto cleanup;
+		client = connect_to_addr(SOCK_STREAM, &expected, len, &client_opts);
+		close_netns(pod_tok);
+		pod_tok = NULL;
+		if (!ASSERT_GE(client, 0, "connect_client"))
+			goto cleanup;
+		accepted = accept(server, NULL, NULL);
+		if (!ASSERT_GE(accepted, 0, "accept"))
+			goto cleanup;
+		if (!ASSERT_OK(settimeo(accepted, IO_TIMEOUT_MS),
+			       "accepted_timeout"))
+			goto cleanup;
+		memset(&actual, 0, sizeof(actual));
+		actual_len = sizeof(actual);
+		if (!ASSERT_OK(getsockname(accepted, (void *)&actual, &actual_len),
+			       "getsockname"))
+			goto cleanup;
+		ASSERT_EQ(actual_len, len, "original_address_len");
+		ASSERT_MEMEQ(&actual, &expected, len, "original_destination");
+		if (!ASSERT_EQ(send(client, TEST_DATA, sizeof(buf), 0),
+			       sizeof(buf), "send_client") ||
+		    !ASSERT_EQ(recv(accepted, buf, sizeof(buf), MSG_WAITALL),
+			       sizeof(buf), "recv_server") ||
+		    !ASSERT_MEMEQ(buf, TEST_DATA, sizeof(buf), "server_data") ||
+		    !ASSERT_EQ(send(accepted, buf, sizeof(buf), 0), sizeof(buf),
+			       "send_server") ||
+		    !ASSERT_EQ(recv(client, buf, sizeof(buf), MSG_WAITALL),
+			       sizeof(buf), "recv_client") ||
+		    !ASSERT_MEMEQ(buf, TEST_DATA, sizeof(buf), "client_data"))
+			goto cleanup;
+		if (i == TEST_ITERATIONS - 1)
+			check_timewait(skel, family, accepted, client);
+		close(accepted);
+		accepted = -1;
+		close(client);
+		client = -1;
+	}
+	if (!ASSERT_OK(bpf_link__detach(link), "detach_netkit"))
+		goto cleanup;
+	ASSERT_GE(skel->bss->listener_assignments, TEST_ITERATIONS,
+		  "listener_assignments");
+	ASSERT_GT(skel->bss->established_assignments, 0, "established_assignments");
+	ASSERT_GT(skel->bss->request_rejections, 0, "request_rejections");
+	ASSERT_EQ(skel->bss->assign_errors, 0, "assign_errors");
+cleanup:
+	close_netns(pod_tok);
+	bpf_link__destroy(link);
+	if (accepted >= 0)
+		close(accepted);
+	if (client >= 0)
+		close(client);
+	if (server >= 0)
+		close(server);
+	sk_assign_netkit__destroy(skel);
+	netns_free(pod);
+	netns_free(host);
+}
+
+void test_sk_assign_netkit(void)
+{
+	if (test__start_subtest("tcpv4"))
+		run_netkit(AF_INET);
+	if (test__start_subtest("tcpv6"))
+		run_netkit(AF_INET6);
+}
diff --git a/tools/testing/selftests/bpf/progs/sk_assign_netkit.c b/tools/testing/selftests/bpf/progs/sk_assign_netkit.c
new file mode 100644
index 000000000000..766f21d11772
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/sk_assign_netkit.c
@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdbool.h>
+#include <linux/bpf.h>
+#include <linux/errno.h>
+#include <linux/if_ether.h>
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/tcp.h>
+#include <bpf/bpf_endian.h>
+#include <bpf/bpf_helpers.h>
+
+const volatile __u16 dest_port;
+const volatile __u16 proxy_port;
+__u64 listener_assignments;
+__u64 established_assignments;
+__u64 assign_errors;
+__u64 request_rejections;
+struct bpf_sock_tuple probe_tuple;
+__u32 probe_len;
+__u32 probe_state;
+int probe_result;
+
+SEC("netkit/peer")
+int assign_socket(struct __sk_buff *skb)
+{
+	void *data_end = (void *)(long)skb->data_end;
+	void *data = (void *)(long)skb->data;
+	struct bpf_sock_tuple tuple = {};
+	struct ethhdr *eth = data;
+	struct bpf_sock *sk;
+	struct tcphdr *th;
+	bool ipv4;
+	__u32 len;
+	int ret;
+
+	if (eth + 1 > data_end)
+		return TCX_PASS;
+	if (eth->h_proto == bpf_htons(ETH_P_IP)) {
+		struct iphdr *iph = (void *)(eth + 1);
+
+		if (iph + 1 > data_end || iph->ihl != 5 ||
+		    iph->protocol != IPPROTO_TCP)
+			return TCX_PASS;
+		tuple.ipv4.saddr = iph->saddr;
+		tuple.ipv4.daddr = iph->daddr;
+		th = (void *)(iph + 1);
+		len = sizeof(tuple.ipv4);
+		ipv4 = true;
+	} else if (eth->h_proto == bpf_htons(ETH_P_IPV6)) {
+		struct ipv6hdr *ip6h = (void *)(eth + 1);
+
+		if (ip6h + 1 > data_end || ip6h->nexthdr != IPPROTO_TCP)
+			return TCX_PASS;
+		__builtin_memcpy(tuple.ipv6.saddr, &ip6h->saddr,
+				 sizeof(tuple.ipv6.saddr));
+		__builtin_memcpy(tuple.ipv6.daddr, &ip6h->daddr,
+				 sizeof(tuple.ipv6.daddr));
+		th = (void *)(ip6h + 1);
+		len = sizeof(tuple.ipv6);
+		ipv4 = false;
+	} else {
+		return TCX_PASS;
+	}
+	if (th + 1 > data_end || th->dest != bpf_htons(dest_port))
+		return TCX_PASS;
+	if (ipv4) {
+		tuple.ipv4.sport = th->source;
+		tuple.ipv4.dport = th->dest;
+	} else {
+		tuple.ipv6.sport = th->source;
+		tuple.ipv6.dport = th->dest;
+	}
+
+	sk = bpf_skc_lookup_tcp(skb, &tuple, len, BPF_F_CURRENT_NETNS, 0);
+	if (sk) {
+		if (sk->state == BPF_TCP_NEW_SYN_RECV) {
+			ret = bpf_sk_assign(skb, sk, 0);
+			bpf_sk_release(sk);
+			if (ret == -EOPNOTSUPP)
+				__sync_fetch_and_add(&request_rejections, 1);
+			else
+				__sync_fetch_and_add(&assign_errors, 1);
+			return TCX_PASS;
+		}
+		if (sk->state != BPF_TCP_LISTEN &&
+		    sk->state != BPF_TCP_TIME_WAIT) {
+			if (sk->state == BPF_TCP_ESTABLISHED)
+				__sync_fetch_and_add(&established_assignments, 1);
+			goto assign;
+		}
+		bpf_sk_release(sk);
+	}
+
+	__builtin_memset(&tuple, 0, sizeof(tuple));
+	if (ipv4)
+		tuple.ipv4.dport = bpf_htons(proxy_port);
+	else
+		tuple.ipv6.dport = bpf_htons(proxy_port);
+	sk = bpf_skc_lookup_tcp(skb, &tuple, len, BPF_F_CURRENT_NETNS, 0);
+	if (!sk) {
+		__sync_fetch_and_add(&assign_errors, 1);
+		return TCX_DROP;
+	}
+	__sync_fetch_and_add(&listener_assignments, 1);
+assign:
+	ret = bpf_sk_assign(skb, sk, 0);
+	bpf_sk_release(sk);
+	if (ret) {
+		__sync_fetch_and_add(&assign_errors, 1);
+		return TCX_DROP;
+	}
+	return TCX_PASS;
+}
+
+SEC("tc")
+int probe_timewait(struct __sk_buff *skb)
+{
+	struct bpf_sock *sk;
+
+	if (probe_len == sizeof(probe_tuple.ipv4))
+		sk = bpf_skc_lookup_tcp(skb, &probe_tuple,
+					sizeof(probe_tuple.ipv4),
+					BPF_F_CURRENT_NETNS, 0);
+	else
+		sk = bpf_skc_lookup_tcp(skb, &probe_tuple,
+					sizeof(probe_tuple.ipv6),
+					BPF_F_CURRENT_NETNS, 0);
+	if (!sk)
+		return TCX_PASS;
+	probe_state = sk->state;
+	probe_result = bpf_sk_assign(skb, sk, 0);
+	bpf_sk_release(sk);
+	return TCX_PASS;
+}
+
+char LICENSE[] SEC("license") = "GPL";
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* [PATCH bpf-next 8/8] selftests/bpf: Check assigned socket lifetime across queues and drops
  2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
                   ` (6 preceding siblings ...)
  2026-11-19 14:22 ` [PATCH bpf-next 7/8] selftests/bpf: Exercise netkit socket assignment to a host proxy Nikolay Aleksandrov
@ 2026-11-19 14:22 ` Nikolay Aleksandrov
  7 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 14:22 UTC (permalink / raw)
  To: bpf
  Cc: Nikolay Aleksandrov, Alexei Starovoitov, Daniel Borkmann,
	Andrii Nakryiko, Eduard Zingerman, Kumar Kartikeya Dwivedi,
	Martin KaFai Lau, Song Liu, Yonghong Song, Jiri Olsa,
	Emil Tsalapatis, Ihor Solodrai, Paul Chaignon, Alasdair McWilliam

Exercise assignment across redirects, drops, classic BPF actions and
NFQUEUE, including queued SYN retransmissions.

Keep listeners open while tracing socket puts and checking queued skb
ownership. Use a local CO-RE queue type. Call tracing requires a non-LTO
kernel with dynamic ftrace and BPF trampolines. The tracing subtests do
not support i386 or MIPS64.
Use nft and tc for setup. Skip missing address families, tools and
explicitly disabled prerequisites; fail unexpected setup errors.

Signed-off-by: Nikolay Aleksandrov <razor@blackwall.org>
---
CC: Alexei Starovoitov <ast@kernel.org>
CC: Daniel Borkmann <daniel@iogearbox.net>
CC: Andrii Nakryiko <andrii@kernel.org>
CC: Eduard Zingerman <eddyz87@gmail.com>
CC: Kumar Kartikeya Dwivedi <memxor@gmail.com>
CC: Martin KaFai Lau <martin.lau@linux.dev>
CC: Song Liu <song@kernel.org>
CC: Yonghong Song <yonghong.song@linux.dev>
CC: Jiri Olsa <jolsa@kernel.org>
CC: Emil Tsalapatis <emil@etsalapatis.com>
CC: Ihor Solodrai <ihor.solodrai@linux.dev>
CC: Paul Chaignon <paul@isovalent.com>
CC: Alasdair McWilliam <alasdair.mcwilliam@isovalent.com>

 tools/testing/selftests/bpf/config            |   5 +
 .../selftests/bpf/prog_tests/assign_reuse.c   | 357 ++++++++++++++++++
 .../bpf/prog_tests/sk_assign_netkit.c         | 296 ++++++++++++++-
 .../selftests/bpf/progs/sk_assign_lifetime.c  | 182 +++++++++
 .../selftests/bpf/progs/sk_assign_netkit.c    |  16 +
 .../selftests/bpf/progs/test_assign_reuse.c   |  45 ++-
 tools/testing/selftests/bpf/unpriv_helpers.c  |  16 +
 tools/testing/selftests/bpf/unpriv_helpers.h  |   2 +
 8 files changed, 910 insertions(+), 9 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/progs/sk_assign_lifetime.c

diff --git a/tools/testing/selftests/bpf/config b/tools/testing/selftests/bpf/config
index 30b744844ef5..c3daa319fe5b 100644
--- a/tools/testing/selftests/bpf/config
+++ b/tools/testing/selftests/bpf/config
@@ -59,6 +59,7 @@ CONFIG_LIRC=y
 CONFIG_LIVEPATCH=y
 CONFIG_LWTUNNEL=y
 CONFIG_LWTUNNEL_BPF=y
+CONFIG_MEMBARRIER=y
 CONFIG_MEMCG=y
 CONFIG_MODULE_SIG=y
 CONFIG_MODULE_SRCVERSION_ALL=y
@@ -69,6 +70,7 @@ CONFIG_MPLS=y
 CONFIG_MPLS_IPTUNNEL=y
 CONFIG_MPLS_ROUTING=y
 CONFIG_MPTCP=y
+CONFIG_NET_ACT_BPF=y
 CONFIG_NET_ACT_GACT=y
 CONFIG_NET_ACT_MIRRED=y
 CONFIG_NET_ACT_SKBMOD=y
@@ -87,6 +89,7 @@ CONFIG_NET_SCH_BPF=y
 CONFIG_NET_SCH_FQ=y
 CONFIG_NET_SCH_INGRESS=y
 CONFIG_NET_SCH_HTB=y
+CONFIG_NET_SCH_PLUG=y
 CONFIG_NET_SCH_RED=y
 CONFIG_NET_SCHED=y
 CONFIG_NETDEVSIM=y
@@ -114,7 +117,9 @@ CONFIG_NETFILTER_XTABLES_LEGACY=y
 CONFIG_NF_FLOW_TABLE=y
 CONFIG_NF_FLOW_TABLE_INET=y
 CONFIG_NETFILTER_NETLINK=y
+CONFIG_NETFILTER_NETLINK_QUEUE=y
 CONFIG_NFT_FLOW_OFFLOAD=y
+CONFIG_NFT_QUEUE=y
 CONFIG_IP_NF_IPTABLES=y
 CONFIG_IP6_NF_IPTABLES=y
 CONFIG_IP6_NF_FILTER=y
diff --git a/tools/testing/selftests/bpf/prog_tests/assign_reuse.c b/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
index 7b19193ed3d7..b4e77836b28d 100644
--- a/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
+++ b/tools/testing/selftests/bpf/prog_tests/assign_reuse.c
@@ -3,12 +3,17 @@
 #include <uapi/linux/if_link.h>
 #include <test_progs.h>
 #include <stdint.h>
+#include <net/if.h>
+#include <linux/membarrier.h>
+#include <linux/pkt_sched.h>
 
 #include <netinet/tcp.h>
 #include <netinet/udp.h>
 
 #include "network_helpers.h"
+#include "unpriv_helpers.h"
 #include "test_assign_reuse.skel.h"
+#include "sk_assign_lifetime.skel.h"
 
 #define NS_TEST "assign_reuse"
 #define LOOPBACK 1
@@ -391,6 +396,339 @@ static void run_assign_reuse(int family, int sotype, const char *ip, __u16 port,
 	free_fds(fd_sv, nr_listens);
 }
 
+static struct sk_assign_lifetime *open_release_trace(int server)
+{
+	static const char * const targets[] = { "sock_pfree_ref", "sock_gen_put" };
+	struct sk_assign_lifetime *lifetime;
+	int ret, i;
+
+	if (!kernel_config_has("CONFIG_LTO_NONE=y")) {
+		printf("SKIP: release call tracing requires a confirmed non-LTO kernel\n");
+		test__skip();
+		return NULL;
+	}
+	if (!kernel_config_has("CONFIG_DYNAMIC_FTRACE=y")) {
+		printf("SKIP: release call tracing requires dynamic ftrace\n");
+		test__skip();
+		return NULL;
+	}
+	for (i = 0; i < ARRAY_SIZE(targets); i++) {
+		ret = libbpf_find_vmlinux_btf_id(targets[i], BPF_TRACE_FENTRY);
+		if (ret <= 0) {
+			printf("SKIP: %s tracing is unavailable\n", targets[i]);
+			test__skip();
+			return NULL;
+		}
+	}
+	lifetime = sk_assign_lifetime__open();
+	if (!ASSERT_NEQ(lifetime, NULL, "lifetime_open"))
+		return NULL;
+	lifetime->rodata->release_cookie = cookie(server);
+	bpf_program__set_autoload(lifetime->progs.queue_enter, false);
+	bpf_program__set_autoload(lifetime->progs.queue_observe, false);
+	if (!ASSERT_OK(sk_assign_lifetime__load(lifetime), "lifetime_load") ||
+	    !ASSERT_OK(sk_assign_lifetime__attach(lifetime), "lifetime_attach")) {
+		sk_assign_lifetime__destroy(lifetime);
+		return NULL;
+	}
+	return lifetime;
+}
+
+static bool wait_for_release(struct sk_assign_lifetime *lifetime, __u64 packets)
+{
+	int i;
+
+	for (i = 0; i < POLL_RETRIES; i++) {
+		if (__atomic_load_n(&lifetime->bss->released_packets,
+				    __ATOMIC_ACQUIRE) >= packets)
+			break;
+		usleep(POLL_INTERVAL_US);
+	}
+	return ASSERT_EQ(lifetime->bss->released_packets, packets,
+			 "released_packets") &&
+	       ASSERT_EQ(lifetime->bss->release_errors, 0, "release_errors");
+}
+
+static bool action_setup_ok(int err, const char *feature)
+{
+	if (err == -ENOENT || err == -EOPNOTSUPP) {
+		printf("SKIP: %s is unavailable\n", feature);
+		test__skip();
+		return false;
+	}
+	return ASSERT_OK(err, feature);
+}
+
+static void run_assign_redirect(int family, const char *ip, bool egress,
+				bool drop)
+{
+	bool hook_created = false, tc_attached = false;
+	struct sk_assign_lifetime *lifetime = NULL;
+	DECLARE_LIBBPF_OPTS(bpf_tc_hook, rx_hook,
+		.ifindex = LOOPBACK,
+		.attach_point = BPF_TC_INGRESS,
+	);
+	DECLARE_LIBBPF_OPTS(bpf_tc_hook, tc_hook,
+		.ifindex = LOOPBACK,
+		.attach_point = egress ? BPF_TC_EGRESS : BPF_TC_INGRESS,
+	);
+	DECLARE_LIBBPF_OPTS(bpf_tc_opts, tc_opts,
+		.handle = 1,
+		.priority = 1,
+	);
+	struct test_assign_reuse *skel = NULL;
+	bool rx_attached = false;
+	const int zero = 0;
+	int server = -1;
+	int ret, i, j;
+	__u64 fd_val;
+
+	if (!setup_family(family))
+		goto cleanup;
+	skel = test_assign_reuse__open();
+	if (!ASSERT_OK_PTR(skel, "skel_open"))
+		goto cleanup;
+	skel->rodata->dest_port = PORT;
+	skel->rodata->check_redirect = true;
+	skel->rodata->drop_after_assign = drop;
+	if (!ASSERT_OK(test_assign_reuse__load(skel), "skel_load"))
+		goto cleanup;
+	server = start_server(family, SOCK_DGRAM, ip, PORT, IO_TIMEOUT_MS);
+	if (!ASSERT_GE(server, 0, "start_server"))
+		goto cleanup;
+	fd_val = server;
+	ret = bpf_map_update_elem(bpf_map__fd(skel->maps.sk_map),
+				  &zero, &fd_val, BPF_NOEXIST);
+	if (!ASSERT_OK(ret, "sk_map_update"))
+		goto cleanup;
+	if (egress) {
+		lifetime = open_release_trace(server);
+		if (!lifetime)
+			goto cleanup;
+	}
+	ret = bpf_tc_hook_create(&tc_hook);
+	if (!ret)
+		hook_created = true;
+	if (!action_setup_ok(ret == -EEXIST ? 0 : ret, "bpf_tc_hook_create"))
+		goto cleanup;
+	tc_opts.prog_fd = bpf_program__fd(skel->progs.tc_main);
+	if (!action_setup_ok(bpf_tc_attach(&tc_hook, &tc_opts), "bpf_tc_attach"))
+		goto cleanup;
+	tc_attached = true;
+	if (egress && !drop) {
+		tc_opts.prog_id = 0;
+		if (!action_setup_ok(bpf_tc_attach(&rx_hook, &tc_opts),
+				     "attach_observer"))
+			goto cleanup;
+		rx_attached = true;
+	}
+	for (i = 0; i < TEST_ITERATIONS; i++) {
+		ASSERT_EQ(echo_test_udp(server), EAGAIN, "packet_dropped");
+		for (j = 0; j < POLL_RETRIES; j++) {
+			if (__atomic_load_n(&skel->bss->completed_packets,
+					    __ATOMIC_ACQUIRE) >= i + 1)
+				break;
+			usleep(POLL_INTERVAL_US);
+		}
+		if (!ASSERT_EQ(skel->bss->completed_packets, i + 1,
+			       "observer_completed"))
+			goto cleanup;
+		if (egress && !wait_for_release(lifetime, i + 1))
+			goto cleanup;
+		ASSERT_EQ(skel->bss->assign_calls, i + 1, "assign_calls");
+		ASSERT_EQ(skel->bss->assign_errors, 0, "assign_errors");
+		ASSERT_EQ(skel->bss->redirected_packets, drop ? 0 : i + 1,
+			  "redirected_packets");
+		ASSERT_EQ(skel->bss->redirected_sockets,
+			  egress && !drop ? i + 1 : 0, "redirected_sockets");
+	}
+cleanup:
+	if (rx_attached) {
+		tc_opts.flags = 0;
+		tc_opts.prog_fd = 0;
+		tc_opts.prog_id = 0;
+		ASSERT_OK(bpf_tc_detach(&rx_hook, &tc_opts), "detach_observer");
+	}
+	if (tc_attached) {
+		tc_opts.flags = 0;
+		tc_opts.prog_fd = 0;
+		tc_opts.prog_id = 0;
+		ASSERT_OK(bpf_tc_detach(&tc_hook, &tc_opts), "bpf_tc_detach");
+	}
+	if (hook_created) {
+		tc_hook.attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS;
+		bpf_tc_hook_destroy(&tc_hook);
+	}
+	sk_assign_lifetime__destroy(lifetime);
+	test_assign_reuse__destroy(skel);
+	if (server >= 0)
+		close(server);
+}
+
+static int action_filter_add(const char *pin_path, bool egress, bool redirect)
+{
+	const char *direction = egress ? "egress" : "ingress";
+	const char *filter = "tc filter add dev lo";
+	const char *next;
+	char action[128];
+
+	snprintf(action, sizeof(action), "action bpf object-pinned %s pipe",
+		 pin_path);
+	if (!egress)
+		next = "action mirred egress redirect dev assign_dummy";
+	else
+		next = redirect ? "" : action;
+	return SYS_NOFAIL("%s %s protocol all pref 1 handle 1 matchall %s %s",
+			  filter, direction, action, next);
+}
+
+static void run_assign_action(bool egress, bool redirect)
+{
+	bool lo_created = false, device = false, plug_created = false;
+	DECLARE_LIBBPF_OPTS(bpf_tc_hook, plug_hook,
+		.attach_point = BPF_TC_QDISC,
+		.parent = TC_H_ROOT,
+		.qdisc = "plug",
+	);
+	struct sk_assign_lifetime *lifetime = NULL;
+	DECLARE_LIBBPF_OPTS(bpf_tc_hook, lo_hook,
+		.ifindex = LOOPBACK,
+		.attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS,
+	);
+	DECLARE_LIBBPF_OPTS(bpf_tc_hook, hook,
+		.attach_point = BPF_TC_EGRESS,
+	);
+	DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts,
+		.handle = 1,
+		.priority = 1,
+	);
+	struct test_assign_reuse *skel = NULL;
+	bool prog_pinned = false;
+	char pin_path[64];
+	int server = -1;
+	__u64 fd_val;
+	int zero = 0;
+	int ret, i;
+
+	if (!setup_family(AF_INET))
+		return;
+	if (SYS_NOFAIL("tc -V")) {
+		printf("Missing required tc tool\n");
+		test__skip();
+		return;
+	}
+	if (kernel_config_disabled("CONFIG_NET_CLS_MATCHALL") ||
+	    kernel_config_disabled("CONFIG_NET_ACT_BPF") ||
+	    (!egress && (kernel_config_disabled("CONFIG_NET_ACT_MIRRED") ||
+			 kernel_config_disabled("CONFIG_DUMMY")))) {
+		printf("SKIP: classic TC action prerequisites are disabled\n");
+		test__skip();
+		return;
+	}
+	if (!egress) {
+		ret = syscall(__NR_membarrier, MEMBARRIER_CMD_QUERY, 0, 0);
+		if ((ret < 0 && errno == ENOSYS) ||
+		    (ret >= 0 && !(ret & MEMBARRIER_CMD_GLOBAL))) {
+			printf("SKIP: global membarrier is unavailable\n");
+			test__skip();
+			return;
+		}
+		if (!ASSERT_GE(ret, 0, "membarrier_query"))
+			return;
+	}
+	ret = bpf_tc_hook_create(&lo_hook);
+	if (!action_setup_ok(ret, "clsact"))
+		goto cleanup;
+	lo_created = true;
+	if (!egress) {
+		SYS(cleanup, "ip link add assign_dummy type dummy");
+		device = true;
+		SYS(cleanup, "ip link set assign_dummy up");
+		hook.ifindex = if_nametoindex("assign_dummy");
+		plug_hook.ifindex = hook.ifindex;
+		if (!action_setup_ok(bpf_tc_hook_create(&plug_hook), "plug"))
+			goto cleanup;
+		plug_created = true;
+		if (!action_setup_ok(bpf_tc_hook_create(&hook), "observer_clsact"))
+			goto cleanup;
+	} else {
+		hook.ifindex = LOOPBACK;
+		hook.attach_point = BPF_TC_INGRESS;
+	}
+	skel = test_assign_reuse__open();
+	if (!ASSERT_OK_PTR(skel, "skel_open"))
+		goto cleanup;
+	skel->rodata->dest_port = PORT;
+	skel->rodata->classic_action = true;
+	skel->rodata->redirect_action = redirect;
+	skel->rodata->pass_observer = !egress;
+	skel->rodata->check_redirect = true;
+	if (!ASSERT_OK(test_assign_reuse__load(skel), "skel_load"))
+		goto cleanup;
+	server = start_server(AF_INET, SOCK_DGRAM, "127.0.0.1", PORT,
+			      IO_TIMEOUT_MS);
+	if (!ASSERT_GE(server, 0, "start_server"))
+		goto cleanup;
+	fd_val = server;
+	if (!ASSERT_OK(bpf_map_update_elem(bpf_map__fd(skel->maps.sk_map),
+					   &zero, &fd_val, BPF_NOEXIST), "sk_map_update"))
+		goto cleanup;
+	if (egress) {
+		lifetime = open_release_trace(server);
+		if (!lifetime)
+			goto cleanup;
+	}
+	if (!egress || redirect) {
+		opts.prog_fd = bpf_program__fd(skel->progs.tc_main);
+		if (!action_setup_ok(bpf_tc_attach(&hook, &opts), "observer_attach"))
+			goto cleanup;
+	}
+	snprintf(pin_path, sizeof(pin_path), "/sys/fs/bpf/sk_assign_action_%d",
+		 getpid());
+	ret = bpf_program__pin(skel->progs.action_assign, pin_path);
+	if (!ASSERT_OK(ret, "pin_action"))
+		goto cleanup;
+	prog_pinned = true;
+	if (!ASSERT_OK(action_filter_add(pin_path, egress, redirect),
+		       "action_filter_add"))
+		goto cleanup;
+	if (!ASSERT_EQ(echo_test_udp(server), EAGAIN, "packet_not_delivered"))
+		goto cleanup;
+	for (i = 0; i < POLL_RETRIES; i++) {
+		if (__atomic_load_n(&skel->bss->completed_packets, __ATOMIC_ACQUIRE))
+			break;
+		usleep(POLL_INTERVAL_US);
+	}
+	if (!ASSERT_EQ(skel->bss->completed_packets, 1, "observer_completed") ||
+	    !ASSERT_EQ(skel->bss->assign_calls, 1, "assign_calls") ||
+	    !ASSERT_EQ(skel->bss->assign_errors, 0, "assign_errors") ||
+	    !ASSERT_EQ(skel->bss->redirected_sockets, egress, "assigned_socket"))
+		goto cleanup;
+	if (egress && !wait_for_release(lifetime, 1))
+		goto cleanup;
+	if (!ASSERT_OK(bpf_map_delete_elem(bpf_map__fd(skel->maps.sk_map), &zero),
+		       "sk_map_delete"))
+		goto cleanup;
+	close(server);
+	server = -1;
+	if (!egress && !ASSERT_OK(kern_sync_rcu(), "sync_rcu"))
+		goto cleanup;
+cleanup:
+	if (prog_pinned)
+		ASSERT_OK(bpf_program__unpin(skel->progs.action_assign, pin_path),
+			  "unpin_action");
+	if (plug_created)
+		ASSERT_OK(bpf_tc_hook_destroy(&plug_hook), "plug_destroy");
+	if (lo_created)
+		ASSERT_OK(bpf_tc_hook_destroy(&lo_hook), "clsact_destroy");
+	if (device)
+		SYS_NOFAIL("ip link del assign_dummy");
+	sk_assign_lifetime__destroy(lifetime);
+	if (server >= 0)
+		close(server);
+	test_assign_reuse__destroy(skel);
+}
+
 void test_assign_reuse(void)
 {
 	struct nstoken *tok = NULL;
@@ -418,6 +756,25 @@ void test_assign_reuse(void)
 		run_assign_reuse(AF_INET, SOCK_DGRAM, "127.0.0.1", PORT, true);
 	if (test__start_subtest("udpv6_egress"))
 		run_assign_reuse(AF_INET6, SOCK_DGRAM, "::1", PORT, true);
+	if (test__start_subtest("ipv4_ingress_redirect"))
+		run_assign_redirect(AF_INET, "127.0.0.1", false, false);
+	if (test__start_subtest("ipv6_ingress_redirect"))
+		run_assign_redirect(AF_INET6, "::1", false, false);
+	if (test__start_subtest("ipv4_egress_redirect"))
+		run_assign_redirect(AF_INET, "127.0.0.1", true, false);
+	if (test__start_subtest("ipv6_egress_redirect"))
+		run_assign_redirect(AF_INET6, "::1", true, false);
+	if (test__start_subtest("ipv4_egress_drop"))
+		run_assign_redirect(AF_INET, "127.0.0.1", true, true);
+	if (test__start_subtest("ipv6_egress_drop"))
+		run_assign_redirect(AF_INET6, "::1", true, true);
+
+	if (test__start_subtest("classic_action_mirred"))
+		run_assign_action(false, false);
+	if (test__start_subtest("classic_action_egress_pipe"))
+		run_assign_action(true, false);
+	if (test__start_subtest("classic_action_egress_redirect"))
+		run_assign_action(true, true);
 
 cleanup:
 	close_netns(tok);
diff --git a/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c b/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
index eb2dd03b923e..17e414efa6e7 100644
--- a/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
+++ b/tools/testing/selftests/bpf/prog_tests/sk_assign_netkit.c
@@ -3,9 +3,15 @@
 #include <netinet/tcp.h>
 #include <uapi/linux/if_link.h>
 #include <test_progs.h>
+#include <stdint.h>
+#include <linux/netfilter.h>
+#include <linux/netfilter/nfnetlink.h>
+#include <linux/netfilter/nfnetlink_queue.h>
 #include "netlink_helpers.h"
 #include "network_helpers.h"
+#include "unpriv_helpers.h"
 #include "sk_assign_netkit.skel.h"
+#include "sk_assign_lifetime.skel.h"
 
 #define NS_HOST "sk_assign_host"
 #define NS_POD "sk_assign_pod"
@@ -18,6 +24,14 @@
 #define IO_TIMEOUT_MS 1000
 #define POLL_RETRIES 5000
 #define POLL_INTERVAL_US 1000
+#define QUEUE_TIMEOUT_MS 5000
+#define QUEUE_CLIENT_TIMEOUT_MS 10000
+
+struct queue_request {
+	struct nlmsghdr n;
+	struct nfgenmsg g;
+	char buf[512];
+};
 
 struct netkit_request {
 	struct nlmsghdr n;
@@ -25,6 +39,238 @@ struct netkit_request {
 	char buf[1024];
 };
 
+struct queue_worker {
+	struct sk_assign_lifetime *skel;
+	__u64 *measurement_done;
+	__u64 *blocked_syns;
+	pthread_t thread;
+	bool wait_retransmit;
+	int reference_errors;
+	int error;
+	int fd;
+};
+
+static int queue_config(int fd, int type, const void *data, int len)
+{
+	struct sockaddr_nl addr = { .nl_family = AF_NETLINK };
+	struct queue_request req = {
+		.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct nfgenmsg)),
+		.n.nlmsg_type = (NFNL_SUBSYS_QUEUE << 8) | NFQNL_MSG_CONFIG,
+		.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
+		.g.version = NFNETLINK_V0,
+	};
+	struct nlmsgerr *err;
+	char reply[512];
+	int ret;
+
+	addattr_l(&req.n, sizeof(req), type, data, len);
+	ret = sendto(fd, &req, req.n.nlmsg_len, 0, (void *)&addr, sizeof(addr));
+	if (ret < 0)
+		return -errno;
+	ret = recv(fd, reply, sizeof(reply), 0);
+	if (ret < 0)
+		return -errno;
+	if (ret < NLMSG_LENGTH(sizeof(*err)))
+		return -EIO;
+	if (((struct nlmsghdr *)reply)->nlmsg_type != NLMSG_ERROR)
+		return -EPROTO;
+	err = NLMSG_DATA((struct nlmsghdr *)reply);
+	return err->error;
+}
+
+static int queue_open(void)
+{
+	struct nfqnl_msg_config_cmd cmd = { .command = NFQNL_CFG_CMD_BIND };
+	struct sockaddr_nl addr = { .nl_family = AF_NETLINK };
+	struct nfqnl_msg_config_params params = {
+		.copy_range = htonl(UINT16_MAX),
+		.copy_mode = NFQNL_COPY_PACKET,
+	};
+	int fd, err;
+
+	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER);
+	if (fd < 0)
+		return -errno;
+	if (bind(fd, (void *)&addr, sizeof(addr)) ||
+	    settimeo(fd, QUEUE_TIMEOUT_MS)) {
+		err = -errno;
+		goto out;
+	}
+	err = queue_config(fd, NFQA_CFG_CMD, &cmd, sizeof(cmd));
+	if (err)
+		goto out;
+	err = queue_config(fd, NFQA_CFG_PARAMS, &params, sizeof(params));
+	if (!err)
+		return fd;
+out:
+	close(fd);
+	return err;
+}
+
+static bool queue_tracing_target(struct bpf_program *prog, const char *name)
+{
+	int err;
+
+	err = bpf_program__set_attach_target(prog, 0, name);
+	if (err == -ESRCH || err == -ENOENT) {
+		printf("SKIP: %s BTF is unavailable\n", name);
+		test__skip();
+		return false;
+	}
+	return ASSERT_OK(err, "tracing_target");
+}
+
+static void *queue_verdict(void *arg)
+{
+	struct nfqnl_msg_verdict_hdr verdict = { .verdict = htonl(NF_ACCEPT) };
+	struct sockaddr_nl addr = { .nl_family = AF_NETLINK };
+	struct queue_worker *worker = arg;
+	struct nfqnl_msg_packet_hdr *hdr;
+	struct queue_request req = {
+		.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct nfgenmsg)),
+		.n.nlmsg_type = (NFNL_SUBSYS_QUEUE << 8) | NFQNL_MSG_VERDICT,
+		.n.nlmsg_flags = NLM_F_REQUEST,
+		.g.version = NFNETLINK_V0,
+	};
+	char buf[UINT16_MAX + 1];
+	__u32 errors, mark = 0;
+	struct nlmsghdr *nlh;
+	bool packet = false;
+	struct rtattr *attr;
+	int fd, ret, len, i;
+
+	ret = recv(worker->fd, buf, sizeof(buf), 0);
+	if (ret < 0) {
+		worker->error = -errno;
+		return NULL;
+	}
+	nlh = (void *)buf;
+	if (!NLMSG_OK(nlh, ret) ||
+	    nlh->nlmsg_type != ((NFNL_SUBSYS_QUEUE << 8) | NFQNL_MSG_PACKET)) {
+		worker->error = -EPROTO;
+		return NULL;
+	}
+	len = nlh->nlmsg_len - NLMSG_LENGTH(sizeof(struct nfgenmsg));
+	attr = (void *)((char *)NLMSG_DATA(nlh) +
+		       NLMSG_ALIGN(sizeof(struct nfgenmsg)));
+	for (; RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) {
+		switch (attr->rta_type & NLA_TYPE_MASK) {
+		case NFQA_PACKET_HDR:
+			if (RTA_PAYLOAD(attr) < sizeof(*hdr))
+				goto invalid;
+			hdr = RTA_DATA(attr);
+			verdict.id = hdr->packet_id;
+			packet = true;
+			break;
+		case NFQA_MARK:
+			if (RTA_PAYLOAD(attr) != sizeof(mark))
+				goto invalid;
+			memcpy(&mark, RTA_DATA(attr), sizeof(mark));
+			mark = ntohl(mark);
+			break;
+		}
+	}
+	if (!packet || !mark)
+		goto invalid;
+	if (worker->wait_retransmit) {
+		for (i = 0; i < POLL_RETRIES; i++) {
+			if (__atomic_load_n(worker->blocked_syns, __ATOMIC_RELAXED))
+				break;
+			usleep(POLL_INTERVAL_US);
+		}
+		if (i == POLL_RETRIES)
+			worker->error = -ETIMEDOUT;
+	}
+	fd = bpf_map__fd(worker->skel->maps.observed);
+	ret = bpf_map_lookup_elem(fd, &mark, &errors);
+	if (ret) {
+		worker->error = -errno;
+	} else {
+		worker->reference_errors = errors;
+		if (bpf_map_delete_elem(fd, &mark))
+			worker->error = -errno;
+	}
+	__atomic_store_n(worker->measurement_done, 1, __ATOMIC_RELEASE);
+	addattr_l(&req.n, sizeof(req), NFQA_VERDICT_HDR, &verdict, sizeof(verdict));
+	ret = sendto(worker->fd, &req, req.n.nlmsg_len, 0,
+		     (void *)&addr, sizeof(addr));
+	if (ret < 0)
+		worker->error = -errno;
+	return NULL;
+invalid:
+	worker->error = -EPROTO;
+	return NULL;
+}
+
+static bool setup_nfqueue(struct sk_assign_netkit *skel,
+			  struct queue_worker *worker, int server, int family,
+			  bool retransmit)
+{
+	const char *nft_family = family == AF_INET ? "ip" : "ip6";
+	socklen_t cookie_len = sizeof(__u64);
+	struct sk_assign_lifetime *lifetime;
+	__u64 cookie;
+
+	if (!kernel_config_has("CONFIG_LTO_NONE=y")) {
+		printf("SKIP: queue tracing requires a confirmed non-LTO kernel\n");
+		test__skip();
+		return false;
+	}
+	if (!kernel_config_has("CONFIG_DYNAMIC_FTRACE=y")) {
+		printf("SKIP: queue tracing requires dynamic ftrace\n");
+		test__skip();
+		return false;
+	}
+	if (kernel_config_disabled("CONFIG_NF_TABLES") ||
+	    kernel_config_disabled("CONFIG_NFT_QUEUE") ||
+	    kernel_config_disabled(family == AF_INET ? "CONFIG_NF_TABLES_IPV4" :
+						    "CONFIG_NF_TABLES_IPV6")) {
+		printf("SKIP: nftables queue or family support is disabled\n");
+		test__skip();
+		return false;
+	}
+	worker->fd = queue_open();
+	if (worker->fd == -EPROTONOSUPPORT || worker->fd == -EOPNOTSUPP ||
+	    worker->fd == -EINVAL) {
+		printf("SKIP: NFQUEUE is unavailable\n");
+		test__skip();
+		return false;
+	}
+	if (!ASSERT_GE(worker->fd, 0, "queue_open"))
+		return false;
+	if (!ASSERT_OK(getsockopt(server, SOL_SOCKET, SO_COOKIE, &cookie,
+				  &cookie_len), "listener_cookie"))
+		return false;
+	worker->skel = sk_assign_lifetime__open();
+	lifetime = worker->skel;
+	if (!ASSERT_OK_PTR(lifetime, "lifetime_open"))
+		return false;
+	lifetime->rodata->listener_cookie = cookie;
+	bpf_program__set_autoload(lifetime->progs.release_enter, false);
+	bpf_program__set_autoload(lifetime->progs.release_exit, false);
+	bpf_program__set_autoload(lifetime->progs.release_put, false);
+	if (!queue_tracing_target(lifetime->progs.queue_enter, "nf_queue") ||
+	    !queue_tracing_target(lifetime->progs.queue_observe,
+				  "nfqnl_enqueue_packet"))
+		return false;
+	if (!ASSERT_OK(sk_assign_lifetime__load(lifetime), "lifetime_load"))
+		return false;
+	if (!ASSERT_OK(sk_assign_lifetime__attach(lifetime), "lifetime_attach"))
+		return false;
+	worker->measurement_done = &skel->bss->measurement_done;
+	worker->blocked_syns = &skel->bss->blocked_syns;
+	worker->wait_retransmit = retransmit;
+	SYS(out, "nft add table %s sk_assign", nft_family);
+	SYS(out, "nft add chain %s sk_assign pre '%s'", nft_family,
+	    "{ type filter hook prerouting priority 0; }");
+	SYS(out, "nft add rule %s sk_assign pre meta mark 1 queue num 0",
+	    nft_family);
+	return ASSERT_OK(pthread_create(&worker->thread, NULL, queue_verdict,
+				       worker), "queue_thread");
+out:
+	return false;
+}
+
 static int create_netkit(void)
 {
 	struct rtattr *linkinfo, *data, *peer_info;
@@ -148,13 +394,16 @@ static int enable_netns_ipv6(const char *name)
 	return err;
 }
 
-static void run_netkit(int family)
+static void run_netkit(int family, bool nfqueue, bool retransmit)
 {
 	const char *dest = family == AF_INET ? "198.18.0.99" : "2001:db8:99::99";
-	struct network_helper_opts client_opts = { .timeout_ms = IO_TIMEOUT_MS };
+	struct queue_worker worker = { .reference_errors = -1, .fd = -1 };
 	const char *bind_addr = family == AF_INET ? "0.0.0.0" : "::";
 	int server = -1, client = -1, accepted = -1;
 	struct netns_obj *host = NULL, *pod = NULL;
+	struct network_helper_opts client_opts = {
+		.timeout_ms = IO_TIMEOUT_MS,
+	};
 	struct sockaddr_storage expected, actual;
 	struct sk_assign_netkit *skel = NULL;
 	struct network_helper_opts opts = {
@@ -165,9 +414,15 @@ static void run_netkit(int family)
 	char buf[sizeof(TEST_DATA) - 1];
 	struct nstoken *pod_tok = NULL;
 	struct bpf_link *link = NULL;
+	bool worker_started = false;
 	socklen_t len, actual_len;
 	int i, err;
 
+	if (nfqueue && SYS_NOFAIL("nft -v")) {
+		printf("Missing required nft tool\n");
+		test__skip();
+		return;
+	}
 	err = socket(family, SOCK_STREAM, 0);
 	if (err < 0 && errno == EAFNOSUPPORT) {
 		printf("SKIP: address family %d is unavailable\n", family);
@@ -224,6 +479,7 @@ static void run_netkit(int family)
 		goto cleanup;
 	skel->rodata->dest_port = DEST_PORT;
 	skel->rodata->proxy_port = PROXY_PORT;
+	skel->rodata->measure_queue = nfqueue;
 	if (!ASSERT_OK(sk_assign_netkit__load(skel), "skel_load"))
 		goto cleanup;
 	link = bpf_program__attach_netkit(skel->progs.assign_socket,
@@ -234,7 +490,14 @@ static void run_netkit(int family)
 		       "make_sockaddr"))
 		goto cleanup;
 
-	for (i = 0; i < TEST_ITERATIONS; i++) {
+	if (nfqueue) {
+		if (!setup_nfqueue(skel, &worker, server, family, retransmit))
+			goto cleanup;
+		worker_started = true;
+		client_opts.timeout_ms = QUEUE_CLIENT_TIMEOUT_MS;
+	}
+
+	for (i = 0; i < (nfqueue ? 1 : TEST_ITERATIONS); i++) {
 		pod_tok = open_netns(NS_POD);
 		if (!ASSERT_NEQ(pod_tok, NULL, "open_pod"))
 			goto cleanup;
@@ -276,12 +539,23 @@ static void run_netkit(int family)
 	}
 	if (!ASSERT_OK(bpf_link__detach(link), "detach_netkit"))
 		goto cleanup;
-	ASSERT_GE(skel->bss->listener_assignments, TEST_ITERATIONS,
-		  "listener_assignments");
+	ASSERT_GE(skel->bss->listener_assignments,
+		  nfqueue ? 1 : TEST_ITERATIONS, "listener_assignments");
 	ASSERT_GT(skel->bss->established_assignments, 0, "established_assignments");
 	ASSERT_GT(skel->bss->request_rejections, 0, "request_rejections");
 	ASSERT_EQ(skel->bss->assign_errors, 0, "assign_errors");
+	if (retransmit)
+		ASSERT_GT(skel->bss->blocked_syns, 0, "retransmitted_syn_blocked");
 cleanup:
+	if (worker_started) {
+		ASSERT_OK(pthread_join(worker.thread, NULL), "queue_join");
+		ASSERT_OK(worker.error, "queue_verdict");
+		ASSERT_EQ(worker.reference_errors, 0, "queue_references");
+		ASSERT_EQ(worker.skel->bss->queue_errors, 0, "queue_map_errors");
+	}
+	if (worker.fd >= 0)
+		close(worker.fd);
+	sk_assign_lifetime__destroy(worker.skel);
 	close_netns(pod_tok);
 	bpf_link__destroy(link);
 	if (accepted >= 0)
@@ -298,7 +572,15 @@ static void run_netkit(int family)
 void test_sk_assign_netkit(void)
 {
 	if (test__start_subtest("tcpv4"))
-		run_netkit(AF_INET);
+		run_netkit(AF_INET, false, false);
 	if (test__start_subtest("tcpv6"))
-		run_netkit(AF_INET6);
+		run_netkit(AF_INET6, false, false);
+	if (test__start_subtest("tcpv4_nfqueue"))
+		run_netkit(AF_INET, true, false);
+	if (test__start_subtest("tcpv6_nfqueue"))
+		run_netkit(AF_INET6, true, false);
+	if (test__start_subtest("tcpv4_nfqueue_retransmit"))
+		run_netkit(AF_INET, true, true);
+	if (test__start_subtest("tcpv6_nfqueue_retransmit"))
+		run_netkit(AF_INET6, true, true);
 }
diff --git a/tools/testing/selftests/bpf/progs/sk_assign_lifetime.c b/tools/testing/selftests/bpf/progs/sk_assign_lifetime.c
new file mode 100644
index 000000000000..619a52e6bc19
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/sk_assign_lifetime.c
@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_core_read.h>
+#include <bpf/bpf_tracing.h>
+
+struct nf_queue_entry___local {
+	struct sk_buff *skb;
+} __attribute__((preserve_access_index));
+
+struct queue_state {
+	__u64 destructor;
+	__u64 sk;
+	__u32 refs;
+	__u32 mark;
+};
+
+struct {
+	__uint(type, BPF_MAP_TYPE_HASH);
+	__uint(max_entries, 64);
+	__type(key, __u64);
+	__type(value, struct queue_state);
+} queued SEC(".maps");
+
+struct {
+	__uint(type, BPF_MAP_TYPE_HASH);
+	__uint(max_entries, 64);
+	__type(key, __u32);
+	__type(value, __u32);
+} observed SEC(".maps");
+
+struct release_state {
+	__u64 parent;
+	__u64 sk;
+	__u64 puts;
+};
+
+struct {
+	__uint(type, BPF_MAP_TYPE_HASH);
+	__uint(max_entries, 8);
+	__type(key, __u64);
+	__type(value, struct release_state);
+} releasing SEC(".maps");
+
+struct {
+	__uint(type, BPF_MAP_TYPE_HASH);
+	__uint(max_entries, 8);
+	__type(key, __u64);
+	__type(value, __u64);
+} active_releases SEC(".maps");
+
+const volatile __u64 listener_cookie;
+const volatile __u64 release_cookie;
+__u64 released_packets;
+__u64 release_errors;
+__u64 queue_errors;
+
+static __always_inline bool is_test_listener(struct sock *sk)
+{
+	return sk && listener_cookie &&
+	       BPF_CORE_READ(sk, __sk_common.skc_state) == BPF_TCP_LISTEN &&
+	       BPF_CORE_READ(sk, __sk_common.skc_cookie.counter) == listener_cookie;
+}
+
+SEC("fentry/nf_queue")
+int BPF_PROG(queue_enter, struct sk_buff *skb)
+{
+	struct sock *sk = BPF_CORE_READ(skb, sk);
+	struct queue_state state = {};
+	__u64 key = (__u64)skb;
+
+	if (!is_test_listener(sk))
+		return 0;
+	state.refs = BPF_CORE_READ(sk, __sk_common.skc_refcnt.refs.counter);
+	state.sk = (__u64)sk;
+	state.destructor = (__u64)BPF_CORE_READ(skb, destructor);
+	state.mark = BPF_CORE_READ(skb, mark);
+	if (bpf_map_update_elem(&queued, &key, &state, BPF_NOEXIST))
+		__sync_fetch_and_add(&queue_errors, 1);
+	return 0;
+}
+
+SEC("fentry/nfqnl_enqueue_packet")
+int BPF_PROG(queue_observe, struct nf_queue_entry___local *entry,
+	     unsigned int queuenum)
+{
+	struct sk_buff *skb = BPF_CORE_READ(entry, skb);
+	struct queue_state *before;
+	__u64 key = (__u64)skb;
+	__u32 mark, errors;
+	struct sock *sk;
+	__u32 refs;
+
+	sk = BPF_CORE_READ(skb, sk);
+	if (!is_test_listener(sk))
+		return 0;
+	before = bpf_map_lookup_elem(&queued, &key);
+	if (!before)
+		return 0;
+	refs = BPF_CORE_READ(sk, __sk_common.skc_refcnt.refs.counter);
+	mark = BPF_CORE_READ(skb, mark);
+	errors = before->refs < 2 || refs < 2 ||
+		 (__u64)sk != before->sk || mark != before->mark ||
+		 (__u64)BPF_CORE_READ(skb, destructor) != before->destructor;
+	if (bpf_map_update_elem(&observed, &mark, &errors, BPF_NOEXIST))
+		__sync_fetch_and_add(&queue_errors, 1);
+	bpf_map_delete_elem(&queued, &key);
+	return 0;
+}
+
+SEC("fentry/sock_pfree_ref")
+int BPF_PROG(release_enter, struct sk_buff *skb)
+{
+	struct sock *sk = BPF_CORE_READ(skb, sk);
+	__u64 task = bpf_get_current_task();
+	struct release_state state = {};
+	__u64 key = (__u64)skb;
+	__u64 *parent;
+
+	if (!sk || !release_cookie ||
+	    BPF_CORE_READ(sk, __sk_common.skc_cookie.counter) != release_cookie)
+		return 0;
+	parent = bpf_map_lookup_elem(&active_releases, &task);
+	if (parent)
+		state.parent = *parent;
+	state.sk = (__u64)sk;
+	if (bpf_map_update_elem(&releasing, &key, &state, BPF_NOEXIST)) {
+		__sync_fetch_and_add(&release_errors, 1);
+		return 0;
+	}
+	if (bpf_map_update_elem(&active_releases, &task, &key, BPF_ANY)) {
+		__sync_fetch_and_add(&release_errors, 1);
+		bpf_map_delete_elem(&releasing, &key);
+	}
+	return 0;
+}
+
+SEC("fentry/sock_gen_put")
+int BPF_PROG(release_put, struct sock *sk)
+{
+	__u64 task = bpf_get_current_task();
+	struct release_state *state;
+	__u64 *key;
+
+	key = bpf_map_lookup_elem(&active_releases, &task);
+	if (!key)
+		return 0;
+	state = bpf_map_lookup_elem(&releasing, key);
+	if (state && state->sk == (__u64)sk)
+		state->puts++;
+	return 0;
+}
+
+SEC("fexit/sock_pfree_ref")
+int BPF_PROG(release_exit, struct sk_buff *skb)
+{
+	__u64 task = bpf_get_current_task();
+	struct release_state *before;
+	__u64 key = (__u64)skb;
+	__u64 increment = 1;
+	int ret;
+
+	before = bpf_map_lookup_elem(&releasing, &key);
+	if (!before)
+		return 0;
+	if (before->puts != 1)
+		__sync_fetch_and_add(&release_errors, 1);
+	if (before->parent)
+		ret = bpf_map_update_elem(&active_releases, &task,
+					  &before->parent, BPF_EXIST);
+	else
+		ret = bpf_map_delete_elem(&active_releases, &task);
+	if (ret)
+		__sync_fetch_and_add(&release_errors, 1);
+	if (bpf_map_delete_elem(&releasing, &key))
+		__sync_fetch_and_add(&release_errors, 1);
+	asm volatile("%0 = atomic_fetch_add((u64 *)(%1 + 0), %0);"
+		     : "+r"(increment) : "r"(&released_packets) : "memory");
+	return 0;
+}
+
+char LICENSE[] SEC("license") = "GPL";
diff --git a/tools/testing/selftests/bpf/progs/sk_assign_netkit.c b/tools/testing/selftests/bpf/progs/sk_assign_netkit.c
index 766f21d11772..ba9e31d1437d 100644
--- a/tools/testing/selftests/bpf/progs/sk_assign_netkit.c
+++ b/tools/testing/selftests/bpf/progs/sk_assign_netkit.c
@@ -12,10 +12,14 @@
 
 const volatile __u16 dest_port;
 const volatile __u16 proxy_port;
+const volatile bool measure_queue;
 __u64 listener_assignments;
 __u64 established_assignments;
 __u64 assign_errors;
 __u64 request_rejections;
+__u64 measurement_started;
+__u64 measurement_done;
+__u64 blocked_syns;
 struct bpf_sock_tuple probe_tuple;
 __u32 probe_len;
 __u32 probe_state;
@@ -64,6 +68,18 @@ int assign_socket(struct __sk_buff *skb)
 	}
 	if (th + 1 > data_end || th->dest != bpf_htons(dest_port))
 		return TCX_PASS;
+	if (measure_queue) {
+		skb->mark = 0;
+		if (th->syn && !th->ack) {
+			if (__sync_val_compare_and_swap(&measurement_started, 0, 1)) {
+				__sync_fetch_and_add(&blocked_syns, 1);
+				return TCX_DROP;
+			}
+			skb->mark = 1;
+		} else if (!__sync_val_compare_and_swap(&measurement_done, 0, 0)) {
+			return TCX_DROP;
+		}
+	}
 	if (ipv4) {
 		tuple.ipv4.sport = th->source;
 		tuple.ipv4.dport = th->dest;
diff --git a/tools/testing/selftests/bpf/progs/test_assign_reuse.c b/tools/testing/selftests/bpf/progs/test_assign_reuse.c
index 9098fe4707ff..5e77161dc81b 100644
--- a/tools/testing/selftests/bpf/progs/test_assign_reuse.c
+++ b/tools/testing/selftests/bpf/progs/test_assign_reuse.c
@@ -26,8 +26,16 @@ union {
 
 const volatile __u16 dest_port;
 const volatile bool select_sock;
+const volatile bool classic_action;
+const volatile bool redirect_action;
+const volatile bool pass_observer;
+const volatile bool check_redirect;
+const volatile bool drop_after_assign;
 __u64 assign_calls;
 __u64 assign_errors;
+__u64 redirected_packets;
+__u64 redirected_sockets;
+__u64 completed_packets;
 
 struct {
 	__u64 expected_cookie;
@@ -165,6 +173,20 @@ assign_sk(struct __sk_buff *skb, typeof(exchanges[0]) *exchange)
 	bpf_sk_release(sk);
 	if (ret)
 		return TC_ACT_SHOT;
+	if (classic_action) {
+		skb->mark = 1;
+		if (redirect_action)
+			return bpf_redirect(skb->ifindex, BPF_F_INGRESS);
+		return TC_ACT_PIPE;
+	}
+	if (check_redirect) {
+		if (drop_after_assign) {
+			__sync_lock_test_and_set(&completed_packets, assign_calls);
+			return TC_ACT_SHOT;
+		}
+		skb->mark = 1;
+		return bpf_redirect(skb->ifindex, BPF_F_INGRESS);
+	}
 	if (select_sock)
 		return bpf_redirect(skb->ifindex, BPF_F_INGRESS);
 	return TC_ACT_OK;
@@ -212,13 +234,20 @@ maybe_assign_udp(struct __sk_buff *skb, struct udphdr *uh)
 	return assign_sk(skb, exchange);
 }
 
-SEC("tc")
-int tc_main(struct __sk_buff *skb)
+static __always_inline int process_packet(struct __sk_buff *skb)
 {
 	void *data_end = (void *)(long)skb->data_end;
 	void *data = (void *)(long)skb->data;
 	struct ethhdr *eth;
 
+	if (check_redirect && skb->mark == 1) {
+		__sync_fetch_and_add(&redirected_packets, 1);
+		if (skb->sk)
+			__sync_fetch_and_add(&redirected_sockets, 1);
+		__sync_lock_test_and_set(&completed_packets, redirected_packets);
+		return pass_observer ? TC_ACT_OK : TC_ACT_SHOT;
+	}
+
 	eth = (struct ethhdr *)(data);
 	if (eth + 1 > data_end)
 		return TC_ACT_SHOT;
@@ -249,3 +278,15 @@ int tc_main(struct __sk_buff *skb)
 			return TC_ACT_SHOT;
 	}
 }
+
+SEC("tc")
+int tc_main(struct __sk_buff *skb)
+{
+	return process_packet(skb);
+}
+
+SEC("action")
+int action_assign(struct __sk_buff *skb)
+{
+	return process_packet(skb);
+}
diff --git a/tools/testing/selftests/bpf/unpriv_helpers.c b/tools/testing/selftests/bpf/unpriv_helpers.c
index c8dd5d848584..0743bdd416f4 100644
--- a/tools/testing/selftests/bpf/unpriv_helpers.c
+++ b/tools/testing/selftests/bpf/unpriv_helpers.c
@@ -70,6 +70,22 @@ static int config_contains(const char *pat)
 	return 0;
 }
 
+bool kernel_config_has(const char *entry)
+{
+	return config_contains(entry) == 1;
+}
+
+bool kernel_config_disabled(const char *name)
+{
+	char pattern[128];
+	int ret;
+
+	ret = snprintf(pattern, sizeof(pattern), "# %s is not set", name);
+	if (ret < 0 || ret >= sizeof(pattern))
+		return false;
+	return kernel_config_has(pattern);
+}
+
 static bool cmdline_contains(const char *pat)
 {
 	int fd, cnt, ret = false;
diff --git a/tools/testing/selftests/bpf/unpriv_helpers.h b/tools/testing/selftests/bpf/unpriv_helpers.h
index c24d53e14f3a..13758872b7f1 100644
--- a/tools/testing/selftests/bpf/unpriv_helpers.h
+++ b/tools/testing/selftests/bpf/unpriv_helpers.h
@@ -4,6 +4,8 @@
 
 #define UNPRIV_SYSCTL "kernel/unprivileged_bpf_disabled"
 
+bool kernel_config_has(const char *entry);
+bool kernel_config_disabled(const char *name);
 bool get_unpriv_disabled(void);
 bool get_unpriv_sysctl_disabled(void);
 bool get_unpriv_mitigations_disabled(void);
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 15+ messages in thread

* Re: [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect()
  2026-11-19 14:22 ` [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect() Nikolay Aleksandrov
@ 2026-11-19 14:52   ` sashiko-bot
  2026-11-19 15:01     ` Nikolay Aleksandrov
  0 siblings, 1 reply; 15+ messages in thread
From: sashiko-bot @ 2026-11-19 14:52 UTC (permalink / raw)
  To: Nikolay Aleksandrov, bpf

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [High] bpf: unorphaned prefetched sk on peer-ingress redirect in
  skb_do_redirect()
--

commit 49a586a8c784f9d116bbf62d9fbeea56cd7faa45
Author: Daniel Borkmann <daniel@iogearbox.net>

bpf: Orphan prefetched sk on skb_do_redirect()

This commit orphans prefetched sockets in skb_do_redirect() before
redirects other than peer-ingress redirects, preventing RCU-borrowed
listener sockets from outliving their RCU read-side critical section.

> diff --git a/net/core/filter.c b/net/core/filter.c
> index 946b07a17fcec..1ad57a3715343 100644
> --- a/net/core/filter.c
> +++ b/net/core/filter.c
> @@ -2558,6 +2558,15 @@ int skb_do_redirect(struct sk_buff *skb)
>  	ri->flags = 0;
>  	if (unlikely(!dev))
>  		goto out_drop;
> +
> +	/*
> +	 * Prefetched sockets may borrow a listener under RCU. Orphan them
> +	 * before redirects that can outlive this section. Peer ingress
> +	 * stays in the same RCU section.
> +	 */
> +	if (skb_sk_is_prefetched(skb) &&
> +	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
> +		skb_orphan(skb);
>  	if (flags & BPF_F_PEER) {
>  		dev = skb_get_peer_dev(dev);
>  		if (unlikely(!dev ||

[Severity: High]
Should skb_orphan(skb) run unconditionally whenever
skb_sk_is_prefetched(skb) is true, including for peer-ingress redirects
(flags == BPF_F_PEER)?

The BPF_F_PEER path below requires the target peer device to be in a
different network namespace (!net_eq(net, dev_net(dev))), whereas
bpf_sk_assign() and bpf_sk_assign_tcp_reqsk() require sock_net(sk) to
match the pre-redirect device's namespace.  Skipping skb_orphan(skb) on
peer ingress leaves the source namespace's prefetched socket attached to
skb when skb_do_redirect() returns -EAGAIN to re-enter
__netif_receive_skb_core() on the peer device:

- During another_round on the peer device, a TC ingress act_mirred
  redirect (which sets dont_clone = true at TC ingress) or an rx_handler
  such as a bridge port or macvlan/ipvlan can queue skb to an egress
  qdisc, backlog, or workqueue without orphaning skb->sk.  An
  unreferenced RCU-borrowed listener then outlives the RCU section,
  leading to a use-after-free in sock_pfree() or skb_steal_sock().

- If the packet proceeds up the peer namespace's IP stack, ip_rcv_core()
  and ip6_rcv_core() preserve prefetched skb->sk.  Packets routed for
  forwarding in the peer namespace are then dropped by ip_forward() and
  ip6_forward() at if (unlikely(skb->sk)) goto drop, while local
  delivery via inet_steal_sock() steals skb->sk without checking
  net_eq(sock_net(sk), net), delivering the packet to the socket in the
  source namespace and caching a peer-namespace dst_entry in
  sk->sk_rx_dst.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261119142231.2612515-1-razor@blackwall.org?part=1

^ permalink raw reply	[flat|nested] 15+ messages in thread

* Re: [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect()
  2026-11-19 14:52   ` sashiko-bot
@ 2026-11-19 15:01     ` Nikolay Aleksandrov
  0 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 15:01 UTC (permalink / raw)
  To: sashiko-reviews, bpf

On 19/11/2026 16:52, sashiko-bot@kernel.org wrote:
> Thank you for your contribution! Sashiko AI review found 1 potential
> issue to consider:
> - [High] bpf: unorphaned prefetched sk on peer-ingress redirect in
>    skb_do_redirect()
> --
> 
> commit 49a586a8c784f9d116bbf62d9fbeea56cd7faa45
> Author: Daniel Borkmann <daniel@iogearbox.net>
> 
> bpf: Orphan prefetched sk on skb_do_redirect()
> 
> This commit orphans prefetched sockets in skb_do_redirect() before
> redirects other than peer-ingress redirects, preventing RCU-borrowed
> listener sockets from outliving their RCU read-side critical section.
> 
>> diff --git a/net/core/filter.c b/net/core/filter.c
>> index 946b07a17fcec..1ad57a3715343 100644
>> --- a/net/core/filter.c
>> +++ b/net/core/filter.c
>> @@ -2558,6 +2558,15 @@ int skb_do_redirect(struct sk_buff *skb)
>>   	ri->flags = 0;
>>   	if (unlikely(!dev))
>>   		goto out_drop;
>> +
>> +	/*
>> +	 * Prefetched sockets may borrow a listener under RCU. Orphan them
>> +	 * before redirects that can outlive this section. Peer ingress
>> +	 * stays in the same RCU section.
>> +	 */
>> +	if (skb_sk_is_prefetched(skb) &&
>> +	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
>> +		skb_orphan(skb);
>>   	if (flags & BPF_F_PEER) {
>>   		dev = skb_get_peer_dev(dev);
>>   		if (unlikely(!dev ||
> 
> [Severity: High]
> Should skb_orphan(skb) run unconditionally whenever
> skb_sk_is_prefetched(skb) is true, including for peer-ingress redirects
> (flags == BPF_F_PEER)?
> 
> The BPF_F_PEER path below requires the target peer device to be in a
> different network namespace (!net_eq(net, dev_net(dev))), whereas
> bpf_sk_assign() and bpf_sk_assign_tcp_reqsk() require sock_net(sk) to
> match the pre-redirect device's namespace.  Skipping skb_orphan(skb) on
> peer ingress leaves the source namespace's prefetched socket attached to
> skb when skb_do_redirect() returns -EAGAIN to re-enter
> __netif_receive_skb_core() on the peer device:
> 
> - During another_round on the peer device, a TC ingress act_mirred
>    redirect (which sets dont_clone = true at TC ingress) or an rx_handler
>    such as a bridge port or macvlan/ipvlan can queue skb to an egress
>    qdisc, backlog, or workqueue without orphaning skb->sk.  An
>    unreferenced RCU-borrowed listener then outlives the RCU section,
>    leading to a use-after-free in sock_pfree() or skb_steal_sock().
> 
> - If the packet proceeds up the peer namespace's IP stack, ip_rcv_core()
>    and ip6_rcv_core() preserve prefetched skb->sk.  Packets routed for
>    forwarding in the peer namespace are then dropped by ip_forward() and
>    ip6_forward() at if (unlikely(skb->sk)) goto drop, while local
>    delivery via inet_steal_sock() steals skb->sk without checking
>    net_eq(sock_net(sk), net), delivering the packet to the socket in the
>    source namespace and caching a peer-namespace dst_entry in
>    sk->sk_rx_dst.
> 

Interesting, the find is correct and my local Sashiko run did not catch it, obvious as it is.
The fix is simple and as suggested by Sashiko:
   -     if (skb_sk_is_prefetched(skb) &&
   -         (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
   +     if (skb_sk_is_prefetched(skb))
                 skb_orphan(skb);

Will fix it up in v2 after I gather more feedback on the patchset.

Cheers,
  Nik


^ permalink raw reply	[flat|nested] 15+ messages in thread

* Re: [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets
  2026-11-19 14:22 ` [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets Nikolay Aleksandrov
@ 2026-11-19 15:19   ` bot+bpf-ci
  2026-11-19 15:36     ` Nikolay Aleksandrov
  2026-11-19 15:28   ` sashiko-bot
  1 sibling, 1 reply; 15+ messages in thread
From: bot+bpf-ci @ 2026-11-19 15:19 UTC (permalink / raw)
  To: razor, bpf
  Cc: daniel, razor, ayush.sawal, andrew+netdev, davem, edumazet, kuba,
	pabeni, ast, andrii, eddyz87, memxor, martin.lau, song,
	yonghong.song, jolsa, emil, ihor.solodrai, john.fastabend, sdf,
	horms, kuniyu, willemb, jhs, jiri, sd, paul, alasdair.mcwilliam,
	netdev, ast, andrii, daniel, martin.lau, eddyz87, yonghong.song,
	mason, ihor.solodrai

[-- Attachment #1: Type: text/plain, Size: 5812 bytes --]

> bpf: allow bpf_sk_assign on tc egress with refcounted sockets

TL;DR:
- bpf_sk_assign() on egress may hit BUG_ON in skb_orphan() for test-run skbs
  with skb->sk but no destructor
- skb_do_redirect() may keep a borrowed listener via syncookie reqsk, a
  possible use-after-free; also possible socket double-put

> diff --git a/net/core/filter.c b/net/core/filter.c
> --- a/net/core/filter.c
> +++ b/net/core/filter.c
> @@ -2559,14 +2559,17 @@ int skb_do_redirect(struct sk_buff *skb)
>  	if (unlikely(!dev))
>  		goto out_drop;
>
> +#ifdef CONFIG_INET
>  	/*
> -	 * Prefetched sockets may borrow a listener under RCU. Orphan them
> -	 * before redirects that can outlive this section. Peer ingress
> -	 * stays in the same RCU section.
> +	 * Prefetched listeners may be borrowed under RCU. Drop borrowed
> +	 * assignments before redirects that can outlive this section.
> +	 * Peer ingress stays in the same RCU section.
>  	 */
> -	if (skb_sk_is_prefetched(skb) &&
> +	if (skb->destructor == sock_pfree &&
> +	    !sk_is_refcounted(skb->sk) &&
>  	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
>  		skb_orphan(skb);
> +#endif

Can this leave a borrowed listener behind a redirect?

bpf_sk_assign_tcp_reqsk() installs a syncookie request sock whose
rsk_listener is a borrowed SOCK_RCU_FREE listener:

    req = inet_reqsk_alloc(ops, sk, false);   /* no ref on sk */
    req->rsk_listener = sk;
    skb->sk = req_to_sk(req);
    skb->destructor = sock_pfree;

skb->sk is a TCP_NEW_SYN_RECV request sock, so sk_is_refcounted(skb->sk)
is true and the new condition is false.  The skb then keeps the reqsk
across bpf_redirect(ifindex, BPF_F_INGRESS) and non-peer egress
redirects.  For example:

    sch_handle_ingress()
      skb_do_redirect()                    /* no orphan */
        __bpf_redirect_common()
          __bpf_rx_skb()
            dev_forward_skb_nomtu()
              netif_rx_internal()          /* queued past the RCU section */

Later tcp_v4_rcv() -> __inet_lookup_skb() -> inet_steal_sock() ->
skb_steal_sock() takes the syncookie branch:

    *refcounted = false;
    sk = req->rsk_listener;
    req->rsk_listener = NULL;
    return sk;

and inet_steal_sock() dereferences that listener.  If the listener was
closed and its SOCK_RCU_FREE grace period elapsed while the skb sat in
the backlog or a qdisc, is this a use-after-free?

The updated comment says borrowed listener assignments are dropped, and the
commit message describes "sock_pfree + !sk_is_refcounted" as "the true
no-refcount case from ingress", but the reqsk case above is not covered.

Separately, refcounted sock_pfree assignments made at ingress now survive
non-peer redirects into egress.  complete_skb() and
chcr_ktls_copy_record_in_skb() treat any destructor other than
sock_efree/sock_pfree_ref as charged to sk_wmem_alloc, and chcr copies
sock_pfree to nskb without sock_hold().  Would that double-put the socket
when both skbs are freed?  The commit message says only sock_pfree_ref
sockets are meant to be preserved; would testing
skb->destructor == sock_pfree alone, as before, keep that and close both
problems?

[ ... ]

> @@ -8115,21 +8118,26 @@ static const struct bpf_func_proto bpf_tcp_gen_syncookie_proto = {
>
>  BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)
>  {
> +	bool egress = !skb_at_tc_ingress(skb);
> +	bool refcounted;
> +
>  	if (!sk || flags != 0)
>  		return -EINVAL;
> -	if (!skb_at_tc_ingress(skb))
> +	if (egress && (!sk_fullsock(sk) || !sk_is_refcounted(sk) ||
> +		       skb_is_decrypted(skb)))
>  		return -EOPNOTSUPP;
> +	refcounted = egress || sk_is_refcounted(sk);
>  	if (unlikely(dev_net(skb->dev) != sock_net(sk)))
>  		return -ENETUNREACH;
>  	if (sk_unhashed(sk))
>  		return -EOPNOTSUPP;
> -	if (sk_is_refcounted(sk) &&
> +	if (refcounted &&
>  	    unlikely(!refcount_inc_not_zero_acquire(&sk->sk_refcnt)))
>  		return -ENOENT;
>
>  	skb_orphan(skb);
>  	skb->sk = sk;
> -	skb->destructor = sock_pfree;
> +	skb->destructor = egress ? sock_pfree_ref : sock_pfree;

Can skb_orphan() hit BUG_ON(skb->sk) here?

Removing the !skb_at_tc_ingress() rejection lets every non-ingress skb
reach skb_orphan(), including skbs that have skb->sk set and no
destructor.  bpf_prog_test_run_skb() builds exactly such an skb:

    sk = sk_alloc(net, AF_UNSPEC, GFP_USER, &bpf_dummy_proto, 1);
    skb = slab_build_skb(data);
    skb->sk = sk;          /* no destructor */

tc_at_ingress is zero there and convert___skb_to_skb() never sets it, so
skb_at_tc_ingress() is false and the new egress branch is taken.  A tc
program that does bpf_sk_lookup_tcp(skb, &tuple, ..., BPF_F_CURRENT_NETNS,
0) on an established socket and then bpf_sk_assign(skb, sk, 0) passes
sk_fullsock(), sk_is_refcounted(), skb_is_decrypted(), the netns check and
sk_unhashed(), and refcount_inc_not_zero_acquire() succeeds.  Then:

    static __always_inline void skb_orphan(struct sk_buff *skb)
    {
        if (skb->destructor) {
            ...
        } else {
            BUG_ON(skb->sk);   /* skb->sk == dummy sk */
        }
    }

Before this patch the same program got -EOPNOTSUPP and never reached
skb_orphan().  The selftest added later in the series (probe_timewait in
sk_assign_netkit) goes through bpf_prog_test_run_opts() but only avoids
the BUG because its socket is in TIME_WAIT and fails sk_fullsock().  A
later patch in the series that accepts listeners does not add a guard
either.

Could the egress branch reject skbs that have skb->sk set but no
destructor (or the test-run context) before calling skb_orphan()?


---
AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md

CI run summary: https://github.com/kernel-patches/bpf/actions/runs/44548126067

^ permalink raw reply	[flat|nested] 15+ messages in thread

* Re: [PATCH bpf-next 4/8] bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress
  2026-11-19 14:22 ` [PATCH bpf-next 4/8] bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress Nikolay Aleksandrov
@ 2026-11-19 15:24   ` sashiko-bot
  0 siblings, 0 replies; 15+ messages in thread
From: sashiko-bot @ 2026-11-19 15:24 UTC (permalink / raw)
  To: Nikolay Aleksandrov, bpf

Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] bpf: BUG_ON(skb->sk) in skb_orphan() via bpf_sk_assign() in
  bpf_prog_test_run_skb()
- [High] bpf: cross-netns socket leak on tc egress in bpf_sk_assign()
- [High] net: uncharged sock_wfree() on frag_list after egress
  bpf_sk_assign()
- [High] bpf: sock_pfree_ref ownership and sk_wmem_alloc corruption on
  egress
--

commit e7a6cd63b8b9259d47c7f6ec283ab9c14f268028
Author: Daniel Borkmann <daniel@iogearbox.net>

bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress

This commit removes the sk_is_refcounted() restriction in bpf_sk_assign()
on TC egress so that full SOCK_RCU_FREE sockets, such as TCP listeners,
can be assigned with an skb-owned reference.

> diff --git a/net/core/filter.c b/net/core/filter.c
> index feeb752f7a008..4dea2cc84712a 100644
> --- a/net/core/filter.c
> +++ b/net/core/filter.c
> @@ -8123,8 +8123,7 @@ BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)
>  
>  	if (!sk || flags != 0)
>  		return -EINVAL;
> -	if (egress && (!sk_fullsock(sk) || !sk_is_refcounted(sk) ||
> -		       skb_is_decrypted(skb)))
> +	if (egress && (!sk_fullsock(sk) || skb_is_decrypted(skb)))
>  		return -EOPNOTSUPP;
>  	refcounted = egress || sk_is_refcounted(sk);
>  	if (unlikely(dev_net(skb->dev) != sock_net(sk)))

[Severity: High]
Can calling bpf_sk_assign() during BPF_PROG_TEST_RUN trigger BUG_ON(skb->sk)
in skb_orphan()?

In bpf_prog_test_run_skb(), the test skb is built with skb->tc_at_ingress
set to 0, skb->sk pointing to a dummy socket, and skb->destructor left as
NULL:

net/bpf/test_run.c:bpf_prog_test_run_skb() {
	...
	skb = slab_build_skb(data);
	if (!skb) {
		ret = -ENOMEM;
		goto out;
	}
	skb->sk = sk;
	...
}

Because skb_at_tc_ingress(skb) is false, egress is true in bpf_sk_assign().
With this change, passing any hashed full socket in the current netns
(such as a TCP listener or UDP socket from bpf_sk_lookup_tcp() or
bpf_sk_lookup_udp()) now passes the egress check and reaches
skb_orphan(skb), which hits BUG_ON(skb->sk) when skb->destructor is NULL.

[Severity: High]
Can assigning a socket on TC egress leak skb->sk across a network
namespace boundary?

When bpf_sk_assign() runs in sch_handle_egress() on a veth or netkit
device, skb->dev is still in the sender's network namespace, so
dev_net(skb->dev) == sock_net(sk) succeeds and sets skb->destructor to
sock_pfree_ref.  When the packet crosses into the peer's network
namespace, skb_scrub_packet() does not orphan skb->sk, and ip_rcv_core()
and ip6_rcv_core() skip skb_orphan() because skb_sk_is_prefetched(skb) is
true.

In the receiving namespace, inet_steal_sock() and inet6_steal_sock()
return the prefetched socket without checking net_eq(net, sock_net(sk)),
delivering the peer namespace's packet to the sender namespace's TCP
listener or UDP socket (and caching the peer namespace's dst_entry in
sk->sk_rx_dst), while ip_forward() and ip6_forward() drop the packet if
it is routed because skb->sk is non-NULL.

[Severity: High]
Can IP fragmentation after an egress bpf_sk_assign() underflow
sk->sk_wmem_alloc on a frag_list skb?

bpf_sk_assign() attaches sk to skb with destructor sock_pfree_ref and only
takes an sk_refcnt reference without charging sk->sk_wmem_alloc.  If an
skb carrying a frag_list later enters the fastpath in ip_do_fragment() or
ip6_fragment() (for example, after traversing a VRF device with a TC
egress program attached), each fragment is given sock_wfree without
checking is_skb_wmem(skb):

net/ipv4/ip_output.c:ip_do_fragment() {
	...
			BUG_ON(frag->sk);
			if (skb->sk) {
				frag->sk = skb->sk;
				frag->destructor = sock_wfree;
			}
			skb->truesize -= frag->truesize;
	...
}

When those fragments are freed, sock_wfree() subtracts their uncharged
truesize from sk->sk_wmem_alloc, which underflows sk_wmem_alloc on a
SOCK_RCU_FREE listening socket (preventing sk_free() from freeing the
socket on close) or triggers a premature __sk_free() while the socket is
still in use.

[Severity: High]
Can egress paths that assume skb->sk is a write-charged socket corrupt
sock_pfree_ref ownership or leak sk->sk_wmem_alloc?

In skb_expand_head() (reachable after TC egress via bpf_redirect_neigh()
or VRF output when headroom is expanded), is_skb_wmem(skb) is false for
sock_pfree_ref:

net/core/skbuff.c:skb_expand_head() {
	...
	if (skb_shared(skb) || !is_skb_wmem(skb)) {
		struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);

		if (unlikely(!nskb))
			goto fail;

		if (sk)
			skb_set_owner_w(nskb, sk);
		consume_skb(skb);
		skb = nskb;
	}
	...
}

skb_set_owner_w() replaces sock_pfree_ref with sock_wfree and charges
sk->sk_wmem_alloc, while consume_skb(skb) drops the sk_refcnt reference;
because nskb->destructor is now sock_wfree, skb_sk_is_prefetched(nskb) is
false and the receive path orphans the assigned socket.

Similarly, esp_output_head() and esp6_output_head() check
if (sk && sk_fullsock(sk)) rather than is_skb_wmem(skb) before calling
refcount_add(tailen, &sk->sk_wmem_alloc), adding write memory charges that
sock_pfree_ref() never releases and preventing sk_free() from freeing the
socket when closed.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261119142231.2612515-1-razor@blackwall.org?part=4

^ permalink raw reply	[flat|nested] 15+ messages in thread

* Re: [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets
  2026-11-19 14:22 ` [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets Nikolay Aleksandrov
  2026-11-19 15:19   ` bot+bpf-ci
@ 2026-11-19 15:28   ` sashiko-bot
  1 sibling, 0 replies; 15+ messages in thread
From: sashiko-bot @ 2026-11-19 15:28 UTC (permalink / raw)
  To: Nikolay Aleksandrov, bpf

Thank you for your contribution! Sashiko AI review found 9 potential
issues to consider:
- [High] bpf: BUG_ON(skb->sk) in skb_orphan() via bpf_sk_assign() in
  test_run
- [High] bpf: socket protocol and family type confusion via egress
  bpf_sk_assign()
- [High] bpf: cross-netns delivery and ip_forward() drops with
  sock_pfree_ref
- [High] net: sk_wmem_alloc corruption on sock_pfree_ref skbs in frag
  and esp
- [High] bpf: kTLS TX fallback and offload triggered on non-TLS
  sock_pfree_ref skbs
- [High] bpf: UAF of RCU listener in skb_do_redirect() due to
  sk_is_refcounted()
- [High] bpf: refcount underflow and wmem corruption on redirected
  ingress sk_assign
- [High] bpf: missing skb_orphan() for syncookie reqsk in
  skb_do_redirect()
- [Medium] bpf: skb_expand_head() converts sock_pfree_ref ownership into
  sock_wfree
--

commit cb5207c254ec50312656daa003d320c5cdb9abbb
Author: Daniel Borkmann <daniel@iogearbox.net>

bpf: allow bpf_sk_assign on tc egress with refcounted sockets

This commit extends bpf_sk_assign() to support assigning full refcounted
sockets on the TC egress path using sock_pfree_ref as the skb destructor.

> diff --git a/net/core/filter.c b/net/core/filter.c
> index 1ad57a3715343..feeb752f7a008 100644
> --- a/net/core/filter.c
> +++ b/net/core/filter.c
> @@ -2559,14 +2559,17 @@ int skb_do_redirect(struct sk_buff *skb)
>  	if (unlikely(!dev))
>  		goto out_drop;
>  
> +#ifdef CONFIG_INET
>  	/*
> -	 * Prefetched sockets may borrow a listener under RCU. Orphan them
> -	 * before redirects that can outlive this section. Peer ingress
> -	 * stays in the same RCU section.
> +	 * Prefetched listeners may be borrowed under RCU. Drop borrowed
> +	 * assignments before redirects that can outlive this section.
> +	 * Peer ingress stays in the same RCU section.
>  	 */
> -	if (skb_sk_is_prefetched(skb) &&
> +	if (skb->destructor == sock_pfree &&
> +	    !sk_is_refcounted(skb->sk) &&
>  	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
>  		skb_orphan(skb);
> +#endif

[Severity: High]
Does checking !sk_is_refcounted(skb->sk) here preserve unreferenced
syncookie request_socks and non-full sockets across redirects?

sk_is_refcounted() returns !sk_fullsock(sk) || !sock_flag(sk, SOCK_RCU_FREE),
which evaluates to true for TCP_NEW_SYN_RECV and TCP_TIME_WAIT sockets.
When bpf_sk_assign_tcp_reqsk() attaches a syncookie request_sock (with
rsk_refcnt == 0 and an unreferenced RCU pointer in req->rsk_listener) or
ingress bpf_sk_assign() attaches a non-full socket with sock_pfree, this
check skips skb_orphan(skb).  Redirecting the skb across an RCU grace
period then allows skb_steal_sock() or sk_to_full_sk() to dereference a
freed listener socket, and allows non-full sockets onto the egress path.

[Severity: High]
Can a syncookie request_sock from bpf_sk_assign_tcp_reqsk() outlive its
RCU read-side critical section when redirected by skb_do_redirect() or
queued by __nf_queue()?

Because sk_fullsock() is false for TCP_NEW_SYN_RECV,
!sk_is_refcounted(skb->sk) is false in both skb_do_redirect() and
__nf_queue().  If the packet is queued to the receive backlog, an egress
qdisc, or NFQUEUE while the TCP_LISTEN socket in req->rsk_listener closes,
skb_steal_sock() later extracts the dangling req->rsk_listener pointer
with *refcounted = false, causing a use-after-free in tcp_v4_rcv() or
tcp_v6_rcv().

>  	if (flags & BPF_F_PEER) {
>  		dev = skb_get_peer_dev(dev);
>  		if (unlikely(!dev ||

[Severity: High]
When an skb with sock_pfree_ref crosses onto a peer device via
bpf_redirect_peer() or a virtual interface (such as netkit or veth without
GRO), does keeping skb->sk across ip_rcv_core() and ip6_rcv_core() break
forwarding and netns isolation?

Because skb_sk_is_prefetched() is true for sock_pfree_ref, ip_rcv_core()
and ip6_rcv_core() do not orphan skb->sk on the receiving interface:

net/ipv4/ip_input.c:ip_rcv_core() {
	...
	/* Must drop socket now because of tproxy. */
	if (!skb_sk_is_prefetched(skb))
		skb_orphan(skb);
	...
}

If the peer forwards the packet, ip_forward() and ip6_forward() drop it at
if (unlikely(skb->sk)) goto drop.  If the peer is in another network
namespace (which BPF_F_PEER requires) and delivers the packet locally,
inet_steal_sock() and inet6_steal_sock() deliver the packet across
namespaces to the sender namespace's socket and cache the peer namespace's
dst_entry in sk->sk_rx_dst.

[ ... ]

>  	return flags & BPF_F_NEIGH ?
>  	       __bpf_redirect_neigh(skb, dev, flags & BPF_F_NEXTHOP ?
>  				    &ri->nh : NULL) :
>  	       __bpf_redirect(skb, dev, flags);

[Severity: Medium]
What happens if a redirected skb with sock_pfree_ref (or refcounted
sock_pfree) needs headroom expansion in skb_expand_head(), for example via
__bpf_redirect_neigh() -> bpf_out_neigh_v4()?

net/core/skbuff.c:skb_expand_head() {
	...
	if (skb_shared(skb) || !is_skb_wmem(skb)) {
		struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
		...
		if (sk)
			skb_set_owner_w(nskb, sk);
		consume_skb(skb);
		skb = nskb;
	}
	...
}

Because is_skb_wmem(skb) is false for sock_pfree_ref and sock_pfree,
skb_expand_head() converts the skb to sock_wfree via skb_set_owner_w(),
dropping the sk_refcnt held by sock_pfree_ref, charging sk->sk_wmem_alloc,
and clearing skb_sk_is_prefetched().

> @@ -8115,21 +8118,26 @@ static const struct bpf_func_proto bpf_tcp_gen_syncookie_proto = {
>  
>  BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)
>  {
> +	bool egress = !skb_at_tc_ingress(skb);
> +	bool refcounted;
> +
>  	if (!sk || flags != 0)
>  		return -EINVAL;
> -	if (!skb_at_tc_ingress(skb))
> +	if (egress && (!sk_fullsock(sk) || !sk_is_refcounted(sk) ||
> +		       skb_is_decrypted(skb)))
>  		return -EOPNOTSUPP;

[Severity: High]
Can assigning a socket whose family or protocol does not match the packet
on TC egress cause socket type confusion when the packet enters a receive
path?

On egress, bpf_sk_assign() does not check that sk is an AF_INET or
AF_INET6 TCP or UDP socket matching the packet (for instance, a TCP socket
can be assigned to a UDP or IPv6 packet, or ctx->sk from a hashed
AF_PACKET or SOCK_RAW socket can be passed back to bpf_sk_assign()).  When
the packet traverses loopback, veth without GRO, netkit, or bpf_redirect()
with BPF_F_INGRESS, ip_rcv_core() and ip6_rcv_core() preserve skb->sk
because skb_sk_is_prefetched() is true for sock_pfree_ref, and
inet_steal_sock() / inet6_steal_sock() return sk to the packet's L4
handler without checking sk_family or sk_protocol:

include/net/inet_hashtables.h:inet_steal_sock() {
	...
	if (sk->sk_protocol == IPPROTO_TCP) {
		if (sk->sk_state != TCP_LISTEN)
			return sk;
	} else if (sk->sk_protocol == IPPROTO_UDP) {
		if (sk->sk_state != TCP_CLOSE)
			return sk;
	} else {
		return sk;
	}
	...
}

__udp4_lib_rcv() and udpv6_rcv() then cast a stolen tcp_sock or
packet_sock via udp_sk(sk), and tcp_v4_rcv() / tcp_v6_rcv() cast a non-TCP
or AF_INET socket to tcp_sock / inet6_sk(sk), causing out-of-bounds
accesses or a NULL pointer dereference.

[Severity: High]
What happens when bpf_sk_assign() on TC egress assigns a socket that has
kTLS TX device offload enabled (sk->sk_validate_xmit_skb != NULL) to a
non-decrypted packet?

Rejecting skb_is_decrypted(skb) means any packet accepted by egress
bpf_sk_assign() is not an unencrypted kTLS record from sk.  However,
sk_validate_xmit_skb() and tls_is_skb_tx_device_offloaded() only check
skb->sk->sk_validate_xmit_skb, so validate_xmit_skb() or the NIC driver
invokes tls_sw_fallback() or chcr_ktls_xmit() on the packet.  Both
functions unconditionally read tcp_hdr(skb) and skb_tcp_all_headers(skb)
even if the packet is not TCP or skb_transport_header_was_set(skb) is
false, reading skb->head + 0xffff out of bounds or overflowing the 150-byte
stack buffer in chcr_ktls_write_tcp_options() when skb_tcp_all_headers(skb)
exceeds skb->len.

>  
>  	skb_orphan(skb);
>  	skb->sk = sk;
> -	skb->destructor = sock_pfree;
> +	skb->destructor = egress ? sock_pfree_ref : sock_pfree;
>  
>  	return 0;
>  }

[Severity: High]
Does calling bpf_sk_assign() from BPF_PROG_TEST_RUN trigger
BUG_ON(skb->sk) in skb_orphan()?

In bpf_prog_test_run_skb(), the test runner allocates a dummy sk and sets
skb->sk = sk without setting skb->destructor, leaving skb->tc_at_ingress
as 0.  Previously bpf_sk_assign() returned -EOPNOTSUPP when
!skb_at_tc_ingress(skb); now it treats the test skb as egress and calls
skb_orphan(skb), which hits BUG_ON(skb->sk) because skb->destructor is
NULL.

[Severity: High]
Can an skb with sock_pfree_ref corrupt sk->sk_wmem_alloc when fragmented
via a frag_list or encrypted by IPsec ESP?

bpf_sk_assign() does not charge skb->truesize to sk->sk_wmem_alloc, but
the frag_list loop in ip_do_fragment() (and ip6_fragment()) checks only
skb->sk before installing sock_wfree on each child fragment:

net/ipv4/ip_output.c:ip_do_fragment() {
	...
			BUG_ON(frag->sk);
			if (skb->sk) {
				frag->sk = skb->sk;
				frag->destructor = sock_wfree;
			}
			skb->truesize -= frag->truesize;
	...
}

When those fragments are freed, sock_wfree() subtracts their truesize from
sk->sk_wmem_alloc, underflowing the refcount and freeing sk while still in
use.  Conversely, esp_output_head() and esp6_output_head() check
if (sk && sk_fullsock(sk)) and add tailen to sk->sk_wmem_alloc without
checking is_skb_wmem(skb), leaking sk_wmem_alloc because sock_pfree_ref
never uncharges it.

[Severity: High]
When bpf_sk_assign() is called on TC ingress with a refcounted socket, it
takes a reference on sk->sk_refcnt but still sets skb->destructor =
sock_pfree; if skb_do_redirect() then redirects that skb to egress, won't
egress paths see sock_pfree instead of sock_pfree_ref?

Because skb_do_redirect() now preserves sock_pfree when
sk_is_refcounted(skb->sk) is true, the skb enters egress with
skb->destructor == sock_pfree.  chcr_ktls_copy_record_in_skb() then takes
the else branch, charging sk_wmem_alloc instead of calling sock_hold()
while copying sock_pfree to nskb, so freeing both skbs drops sk_refcnt
twice and leaks sk_wmem_alloc.  complete_skb(), skb_orphan_partial(), and
tcf_bpf_act() likewise only check for sock_pfree_ref, corrupting
sk_wmem_alloc on TLS software fallback or orphaning the refcounted socket
in netem and act_bpf.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261119142231.2612515-1-razor@blackwall.org?part=3

^ permalink raw reply	[flat|nested] 15+ messages in thread

* Re: [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets
  2026-11-19 15:19   ` bot+bpf-ci
@ 2026-11-19 15:36     ` Nikolay Aleksandrov
  0 siblings, 0 replies; 15+ messages in thread
From: Nikolay Aleksandrov @ 2026-11-19 15:36 UTC (permalink / raw)
  To: bot+bpf-ci, bpf
  Cc: daniel, ayush.sawal, andrew+netdev, davem, edumazet, kuba, pabeni,
	ast, andrii, eddyz87, memxor, martin.lau, song, yonghong.song,
	jolsa, emil, ihor.solodrai, john.fastabend, sdf, horms, kuniyu,
	willemb, jhs, jiri, sd, paul, alasdair.mcwilliam, netdev,
	martin.lau, mason

On 19/11/2026 17:19, bot+bpf-ci@kernel.org wrote:
>> bpf: allow bpf_sk_assign on tc egress with refcounted sockets
> 
> TL;DR:
> - bpf_sk_assign() on egress may hit BUG_ON in skb_orphan() for test-run skbs
>    with skb->sk but no destructor
> - skb_do_redirect() may keep a borrowed listener via syncookie reqsk, a
>    possible use-after-free; also possible socket double-put
> 

oh well, both are good and valid catches, I will take care of them for v2
my local Sashiko run missed these too

Thanks,
  Nik

>> diff --git a/net/core/filter.c b/net/core/filter.c
>> --- a/net/core/filter.c
>> +++ b/net/core/filter.c
>> @@ -2559,14 +2559,17 @@ int skb_do_redirect(struct sk_buff *skb)
>>   	if (unlikely(!dev))
>>   		goto out_drop;
>>
>> +#ifdef CONFIG_INET
>>   	/*
>> -	 * Prefetched sockets may borrow a listener under RCU. Orphan them
>> -	 * before redirects that can outlive this section. Peer ingress
>> -	 * stays in the same RCU section.
>> +	 * Prefetched listeners may be borrowed under RCU. Drop borrowed
>> +	 * assignments before redirects that can outlive this section.
>> +	 * Peer ingress stays in the same RCU section.
>>   	 */
>> -	if (skb_sk_is_prefetched(skb) &&
>> +	if (skb->destructor == sock_pfree &&
>> +	    !sk_is_refcounted(skb->sk) &&
>>   	    (!(flags & BPF_F_PEER) || (flags & BPF_F_EGRESS)))
>>   		skb_orphan(skb);
>> +#endif
> 
> Can this leave a borrowed listener behind a redirect?
> 
> bpf_sk_assign_tcp_reqsk() installs a syncookie request sock whose
> rsk_listener is a borrowed SOCK_RCU_FREE listener:
> 
>      req = inet_reqsk_alloc(ops, sk, false);   /* no ref on sk */
>      req->rsk_listener = sk;
>      skb->sk = req_to_sk(req);
>      skb->destructor = sock_pfree;
> 
> skb->sk is a TCP_NEW_SYN_RECV request sock, so sk_is_refcounted(skb->sk)
> is true and the new condition is false.  The skb then keeps the reqsk
> across bpf_redirect(ifindex, BPF_F_INGRESS) and non-peer egress
> redirects.  For example:
> 
>      sch_handle_ingress()
>        skb_do_redirect()                    /* no orphan */
>          __bpf_redirect_common()
>            __bpf_rx_skb()
>              dev_forward_skb_nomtu()
>                netif_rx_internal()          /* queued past the RCU section */
> 
> Later tcp_v4_rcv() -> __inet_lookup_skb() -> inet_steal_sock() ->
> skb_steal_sock() takes the syncookie branch:
> 
>      *refcounted = false;
>      sk = req->rsk_listener;
>      req->rsk_listener = NULL;
>      return sk;
> 
> and inet_steal_sock() dereferences that listener.  If the listener was
> closed and its SOCK_RCU_FREE grace period elapsed while the skb sat in
> the backlog or a qdisc, is this a use-after-free?
> 
> The updated comment says borrowed listener assignments are dropped, and the
> commit message describes "sock_pfree + !sk_is_refcounted" as "the true
> no-refcount case from ingress", but the reqsk case above is not covered.
> 
> Separately, refcounted sock_pfree assignments made at ingress now survive
> non-peer redirects into egress.  complete_skb() and
> chcr_ktls_copy_record_in_skb() treat any destructor other than
> sock_efree/sock_pfree_ref as charged to sk_wmem_alloc, and chcr copies
> sock_pfree to nskb without sock_hold().  Would that double-put the socket
> when both skbs are freed?  The commit message says only sock_pfree_ref
> sockets are meant to be preserved; would testing
> skb->destructor == sock_pfree alone, as before, keep that and close both
> problems?
> 
> [ ... ]
> 
>> @@ -8115,21 +8118,26 @@ static const struct bpf_func_proto bpf_tcp_gen_syncookie_proto = {
>>
>>   BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)
>>   {
>> +	bool egress = !skb_at_tc_ingress(skb);
>> +	bool refcounted;
>> +
>>   	if (!sk || flags != 0)
>>   		return -EINVAL;
>> -	if (!skb_at_tc_ingress(skb))
>> +	if (egress && (!sk_fullsock(sk) || !sk_is_refcounted(sk) ||
>> +		       skb_is_decrypted(skb)))
>>   		return -EOPNOTSUPP;
>> +	refcounted = egress || sk_is_refcounted(sk);
>>   	if (unlikely(dev_net(skb->dev) != sock_net(sk)))
>>   		return -ENETUNREACH;
>>   	if (sk_unhashed(sk))
>>   		return -EOPNOTSUPP;
>> -	if (sk_is_refcounted(sk) &&
>> +	if (refcounted &&
>>   	    unlikely(!refcount_inc_not_zero_acquire(&sk->sk_refcnt)))
>>   		return -ENOENT;
>>
>>   	skb_orphan(skb);
>>   	skb->sk = sk;
>> -	skb->destructor = sock_pfree;
>> +	skb->destructor = egress ? sock_pfree_ref : sock_pfree;
> 
> Can skb_orphan() hit BUG_ON(skb->sk) here?
> 
> Removing the !skb_at_tc_ingress() rejection lets every non-ingress skb
> reach skb_orphan(), including skbs that have skb->sk set and no
> destructor.  bpf_prog_test_run_skb() builds exactly such an skb:
> 
>      sk = sk_alloc(net, AF_UNSPEC, GFP_USER, &bpf_dummy_proto, 1);
>      skb = slab_build_skb(data);
>      skb->sk = sk;          /* no destructor */
> 
> tc_at_ingress is zero there and convert___skb_to_skb() never sets it, so
> skb_at_tc_ingress() is false and the new egress branch is taken.  A tc
> program that does bpf_sk_lookup_tcp(skb, &tuple, ..., BPF_F_CURRENT_NETNS,
> 0) on an established socket and then bpf_sk_assign(skb, sk, 0) passes
> sk_fullsock(), sk_is_refcounted(), skb_is_decrypted(), the netns check and
> sk_unhashed(), and refcount_inc_not_zero_acquire() succeeds.  Then:
> 
>      static __always_inline void skb_orphan(struct sk_buff *skb)
>      {
>          if (skb->destructor) {
>              ...
>          } else {
>              BUG_ON(skb->sk);   /* skb->sk == dummy sk */
>          }
>      }
> 
> Before this patch the same program got -EOPNOTSUPP and never reached
> skb_orphan().  The selftest added later in the series (probe_timewait in
> sk_assign_netkit) goes through bpf_prog_test_run_opts() but only avoids
> the BUG because its socket is in TIME_WAIT and fails sk_fullsock().  A
> later patch in the series that accepts listeners does not add a guard
> either.
> 
> Could the egress branch reject skbs that have skb->sk set but no
> destructor (or the test-run context) before calling skb_orphan()?
> 
> 
> ---
> AI reviewed your patch. Please fix the bug or email reply why it's not a bug.
> See: https://github.com/kernel-patches/vmtest/blob/master/ci/claude/README.md
> 
> CI run summary: https://github.com/kernel-patches/bpf/actions/runs/44548126067


^ permalink raw reply	[flat|nested] 15+ messages in thread

end of thread, other threads:[~2026-11-19 15:36 UTC | newest]

Thread overview: 15+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 14:22 [PATCH bpf-next 0/8] bpf: add bpf_sk_assign support on egress Nikolay Aleksandrov
2026-11-19 14:22 ` [PATCH bpf-next 1/8] bpf: Orphan prefetched sk on skb_do_redirect() Nikolay Aleksandrov
2026-11-19 14:52   ` sashiko-bot
2026-11-19 15:01     ` Nikolay Aleksandrov
2026-11-19 14:22 ` [PATCH bpf-next 2/8] net: track references owned by prefetched socket assignments Nikolay Aleksandrov
2026-11-19 14:22 ` [PATCH bpf-next 3/8] bpf: allow bpf_sk_assign on tc egress with refcounted sockets Nikolay Aleksandrov
2026-11-19 15:19   ` bot+bpf-ci
2026-11-19 15:36     ` Nikolay Aleksandrov
2026-11-19 15:28   ` sashiko-bot
2026-11-19 14:22 ` [PATCH bpf-next 4/8] bpf: support SOCK_RCU_FREE sockets in bpf_sk_assign on egress Nikolay Aleksandrov
2026-11-19 15:24   ` sashiko-bot
2026-11-19 14:22 ` [PATCH bpf-next 5/8] selftests/bpf: Delete assign_reuse namespace when opening it fails Nikolay Aleksandrov
2026-11-19 14:22 ` [PATCH bpf-next 6/8] selftests/bpf: Cover egress socket assignment with reuseport Nikolay Aleksandrov
2026-11-19 14:22 ` [PATCH bpf-next 7/8] selftests/bpf: Exercise netkit socket assignment to a host proxy Nikolay Aleksandrov
2026-11-19 14:22 ` [PATCH bpf-next 8/8] selftests/bpf: Check assigned socket lifetime across queues and drops Nikolay Aleksandrov

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox