bpf: Introduce bpf_netpoll
Subsystems (6)
cover bpf: Introduce bpf_netpoll
This patch series introduces bpf_netpoll, a set of BPF kfuncs that allow BPF programs to send UDP packets via the netpoll infrastructure. This provides a mechanism for BPF programs (e.g., LSM hooks) to emit telemetry over UDP without depending on the regular networking stack.
For reference, this was discussed at LSF/MM/BPF 2025[^1] in Montreal, and again at Plumbers 2025 in Tokyo. Liam Wisehart mentioned this work during his presentation of BpfJailer[^2].
The main use case is to be able to completely dispense with agents/daemons for BPF programs after startup. In the case of Isovalent's Tetragon, the idea would be to be able to emit security alerts or export data from BPF even when the agent is down. For meta, according to Liam presentation[^2], this could replace logging via ringbuffers which created cross-binary versioning issues.
The implementation follows the established kfunc lifecycle pattern (create/acquire/release with refcounting, kptr map storage, dtor registration), for example used by the network bpf_crypto kfuncs.
Further patches would extend the bpf_netpoll_send kfunc to more program types. Note that network program types should not encounter recursion issues as netpoll bypasses the network stack and sends directly to the driver.
[^1]: https://lwn.net/Articles/1022034/
[^2]: https://lpc.events/event/19/contributions/2159/
Mahe Tardy (2):
selftests/bpf: Add netpoll kfunc IPv6 variant test selftests/bpf: Add netpoll setup basic tests
Song Liu (2):
bpf: Add netpoll kfuncs for sending UDP packets
selftests/bpf: Add netpoll kfunc sanity test
drivers/net/Kconfig | 11 + include/linux/bpf_netpoll.h | 38 ++++ kernel/bpf/verifier.c | 3 + net/core/Makefile | 1 + net/core/bpf_netpoll.c | 209 ++++++++++++++++++ tools/testing/selftests/bpf/config | 1 + .../selftests/bpf/prog_tests/netpoll.c | 140 ++++++++++++ .../selftests/bpf/progs/netpoll_basic.c | 47 ++++ .../selftests/bpf/progs/netpoll_common.h | 64 ++++++ .../selftests/bpf/progs/netpoll_sanity.c | 135 +++++++++++ 10 files changed, 649 insertions(+) create mode 100644 include/linux/bpf_netpoll.h create mode 100644 net/core/bpf_netpoll.c create mode 100644 tools/testing/selftests/bpf/prog_tests/netpoll.c create mode 100644 tools/testing/selftests/bpf/progs/netpoll_basic.c create mode 100644 tools/testing/selftests/bpf/progs/netpoll_common.h create mode 100644 tools/testing/selftests/bpf/progs/netpoll_sanity.c
Signature · 1 line
2.34.1
RFC PATCH 1/4 bpf: Add netpoll kfuncs for sending UDP packets
From: Song Liu <[email protected]>
Add BPF kfuncs that allow BPF programs to send UDP packets via the netpoll infrastructure. This provides a mechanism for BPF programs (e.g., LSM hooks) to emit telemetry over UDP without depending on the regular networking stack.
The API consists of four kfuncs:
bpf_netpoll_create() - Allocate and set up a netpoll context
(sleepable, SYSCALL prog type only)
bpf_netpoll_acquire() - Acquire a reference to a netpoll context bpf_netpoll_release() - Release a reference (cleanup via
queue_rcu_work since netpoll_cleanup sleeps)
bpf_netpoll_send_udp() - Send a UDP packet (any context, LSM prog
type only for now)
The implementation follows the established kfunc lifecycle pattern (create/acquire/release with refcounting, kptr map storage, dtor registration). The netpoll context is wrapped in a refcounted bpf_netpoll struct. Cleanup is deferred via queue_rcu_work() because netpoll_cleanup() takes rtnl_lock.
AI was used to generate the code and each line was manually reviewed.
--- drivers/net/Kconfig | 11 ++ include/linux/bpf_netpoll.h | 38 +++++++ kernel/bpf/verifier.c | 3 + net/core/Makefile | 1 + net/core/bpf_netpoll.c | 209 ++++++++++++++++++++++++++++++++++++ 5 files changed, 262 insertions(+) create mode 100644 include/linux/bpf_netpoll.h create mode 100644 net/core/bpf_netpoll.c
drivers/net/Kconfig +11 -0
@@ -371,6 +371,17 @@ config NETCONSOLE_PREPEND_RELEASE message. See <file:Documentation/networking/netconsole.rst> for details. +config BPF_NETPOLL + bool "BPF netpoll UDP support" + depends on BPF_SYSCALL && NET + select NETPOLL + help + Enable BPF kfuncs for sending UDP packets via netpoll. + This allows BPF programs to send UDP packets from any + context using the netpoll infrastructure. + + If unsure, say N. + config NETPOLL def_bool NETCONSOLE
include/linux/bpf_netpoll.h new file +38 -0
@@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */ + +#ifndef _BPF_NETPOLL_H +#define _BPF_NETPOLL_H + +#include <linux/types.h> + +#define BPF_NETPOLL_DEV_NAME_LEN 16/* IFNAMSIZ */ + +/** +* struct bpf_netpoll_opts - BPF netpoll initialization parameters +* @dev_name: Network device name (e.g. "eth0"), null-terminated. +* @local_ip: Local IPv4 address in network byte order. 0 = auto-detect. +* @remote_ip: Remote IPv4 address in network byte order. +* @local_port: Local UDP port in host byte order. +* @remote_port: Remote UDP port in host byte order. +* @remote_mac: Remote MAC address (6 bytes). +* @ipv6: Set to 1 for IPv6, 0 for IPv4. +* @reserved: Must be zero. Reserved for future use. +* @local_ip6: Local IPv6 address (16 bytes). Used when ipv6=1. +* Zero = auto-detect. +* @remote_ip6: Remote IPv6 address (16 bytes). Used when ipv6=1. +*/ +struct bpf_netpoll_opts { +char dev_name[BPF_NETPOLL_DEV_NAME_LEN ]; +__be32 local_ip; +__be32 remote_ip; +__u16 local_port; +__u16 remote_port; +__u8 remote_mac[6 ]; +__u8 ipv6; +__u8 reserved; +__u8 local_ip6[16 ]; +__u8 remote_ip6[16 ]; +}; + +#endif /* _BPF_NETPOLL_H */
kernel/bpf/verifier.c +3 -0
@@ -6037,6 +6037,9 @@ BTF_ID(struct, task_struct)#ifdef CONFIG_CRYPTO BTF_ID(struct, bpf_crypto_ctx)#endif +#ifdef CONFIG_BPF_NETPOLL +BTF_ID(struct, bpf_netpoll) +#endif BTF_SET_END (rcu_protected_types) static bool rcu_protected_object(const struct btf *btf, u32 btf_id)
net/core/Makefile +1 -0
@@ -26,6 +26,7 @@ obj-$(CONFIG_PAGE_POOL) += page_pool.o page_pool_user.o obj-$(CONFIG_PROC_FS) += net-procfs.o obj-$(CONFIG_NET_PKTGEN) += pktgen.o obj-$(CONFIG_NETPOLL) += netpoll.o +obj-$(CONFIG_BPF_NETPOLL) += bpf_netpoll.o obj-$(CONFIG_FIB_RULES) += fib_rules.o obj-$(CONFIG_TRACEPOINTS) += net-traces.o obj-$(CONFIG_NET_DROP_MONITOR) += drop_monitor.o
net/core/bpf_netpoll.c new file +209 -0
209 lines not on this page · raw message
Signature · 1 line
2.34.1
[email protected]
AI reviewRe: [RFC PATCH bpf-next 1/4] bpf: Add netpoll kfuncs for sending UDP packets
Is the return value documentation here complete? Tracing the call chain through netpoll_send_udp() -> netpoll_send_skb() -> __netpoll_send_skb(), the latter initializes its return value as…
Quoted 5 lines
net/core/bpf_netpoll.c new file +0
-0
[ ... ]
Quoted 11 lines
+/**
+ *bpf_netpoll_send_udp()- Send a UDP packet via netpoll.
+ * @bnp: The BPF netpoll context. Must be an RCU-protected pointer.
+ * @data: Pointer to the data to send.
+ * @data__sz: Size of the data to send (max 1460 bytes).
+ *
+ * Sends a UDP packet using the netpoll infrastructure. Can be called
+ * from any context (process, softirq, hardirq).
+ *
+ * Return: 0 on success, negative errno on error.
+ */
Is the return value documentation here complete? Tracing the call chain through netpoll_send_udp() -> netpoll_send_skb() -> __netpoll_send_skb(), the latter initializes its return value as NET_XMIT_DROP (which is 1) and returns it when the device is not running or not present:
net/core/netpoll.c:__netpoll_send_skb() {
netdev_tx_t ret = NET_XMIT_DROP;
...
if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
dev_kfree_skb_irq(skb);
goto out;
}
...
ret = NETDEV_TX_OK;
out:
...
return ret;
}That positive 1 propagates back through netpoll_send_udp() which casts it to int and returns it unchanged.
A BPF program following the documented contract and checking ret < 0 for errors would silently miss the case where the packet was dropped because the device went down. Should the comment document this, or should the return value be normalized to a negative errno before returning to the caller?
Quoted 5 lines
net/core/bpf_netpoll.c new file +5
-0+__bpf_kfunc int bpf_netpoll_send_udp(struct bpf_netpoll *bnp, +const void *data,u32 data__sz) +{ +unsigned long flags; +int ret;
net/core/bpf_netpoll.c line 162
Quoted 10 lines
net/core/bpf_netpoll.c new file +10
-0+ +if (data__sz >BPF_NETPOLL_MAX_UDP_CHUNK ) +return -E2BIG ; + +local_irq_save (flags); + ret =netpoll_send_udp (&bnp->np, data, data__sz); +local_irq_restore (flags); + +return ret; +}
---
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/22855649225
Re: [RFC PATCH bpf-next 1/4] bpf: Add netpoll kfuncs for sending UDP packets
In reply to Mahe TardyReview
Quoted 3 lines · Mahe Tardy
(quoted diff) +2
-0+ + bnp = kzalloc(sizeof(*bnp), GFP_KERNEL);
AI generated it and humans reviewed it ?
Sigh. AI does a better job at this.
Think about this line again.
Also, don't bother with RFC. If you want the patches to land don't use RFC tag.
RFC means "I don't know what I'm doing and I'm not asking to land it in this shape".
pw-bot: cr
Re: [RFC PATCH bpf-next 1/4] bpf: Add netpoll kfuncs for sending UDP packets
Quoted 8 lines · Alexei Starovoitov
Review
Quoted 3 lines · Mahe Tardy
(quoted diff) +2
-0+ + bnp = kzalloc(sizeof(*bnp), GFP_KERNEL);AI generated it and humans reviewed it ?
Sigh. AI does a better job at this.
Think about this line again.
Yes I reviewed this, but Song might know more on how this was generated, my experience with handling kernel memory is fairly limited (I'm mostly learning) but this looked good to me.
As I'm seeing it we could have used more modern wrapper like:
bnp = kzalloc_obj(*bnp)
But I'm not sure it would made a fundamental difference here since it would be the exact same flag.
It's called from bpf_netpoll_create, that can be only called from sleepable programs (like SYSCALL here). And it's similar to how the crypto context is allocated in the bpf_crypto_ctx_create kfunc so I'm not sure I understand what's wrong in our variant.
Could you help me and be more explicit on what you think is wrong?
Quoted 5 lines
Also, don't bother with RFC. If you want the patches to land don't use RFC tag.
RFC means "I don't know what I'm doing and I'm not asking to land it in this shape".
Okay thanks for the info, I'll remove the RFC for v2.
Song Liu
reviewerRe: [RFC PATCH bpf-next 1/4] bpf: Add netpoll kfuncs for sending UDP packets
Quoted 7 lines · Mahe Tardy
Quoted 5 lines · Alexei Starovoitov
Quoted 3 lines · Mahe Tardy
(quoted diff) +2
-0+ + bnp = kzalloc(sizeof(*bnp), GFP_KERNEL);
Quoted 7 lines
Quoted 3 lines
AI generated it and humans reviewed it ?
Sigh. AI does a better job at this.
Think about this line again.Yes I reviewed this, but Song might know more on how this was generated, my experience with handling kernel memory is fairly limited (I'm mostly learning) but this looked good to me.
Claude wrote this version before the tree wide kzalloc_obj change. If we redo the vibe coding now, it should use kzalloc_obj instead.
Thanks,
Song
Re: [RFC PATCH bpf-next 1/4] bpf: Add netpoll kfuncs for sending UDP packets
Quoted 13 lines · Song Liu
Quoted 11 lines · Mahe Tardy
Quoted 8 lines · Alexei Starovoitov
Review
Quoted 3 lines · Mahe Tardy
(quoted diff) +2
-0+ + bnp = kzalloc(sizeof(*bnp), GFP_KERNEL);AI generated it and humans reviewed it ?
Sigh. AI does a better job at this.
Think about this line again.
Quoted 6 lines
Quoted 3 lines
Yes I reviewed this, but Song might know more on how this was generated, my experience with handling kernel memory is fairly limited (I'm mostly learning) but this looked good to me.
Claude wrote this version before the tree wide
kzalloc_objchange. If we redo the vibe coding now, it should usekzalloc_objinstead.
That's what I expected :)
RFC PATCH 2/4 selftests/bpf: Add netpoll kfunc sanity test
In reply to Mahe TardyFrom: Song Liu <[email protected]>
Add a selftest that exercises the bpf_netpoll kfuncs end-to-end:
1. A SYSCALL BPF program creates a netpoll context on a dummy network device and stores it in a kptr map.
2. A fentry program is attached to dummy_xmit, the driver function that will receive the netpoll sent packet.
3. An LSM program attached to security_file_open retrieves the context from the map and calls bpf_netpoll_send_udp().
The userspace harness creates a network namespace with a dummy device, runs the setup program, attach the fentry hook then triggers the LSM hook by opening /dev/null. The dummy device accepts all packets, so send_status == 0 confirms success and the packet content is verified by reading the skb from the dummy driver xmit function.
The code was partially generated by AI and each line was manually reviewed.
--- tools/testing/selftests/bpf/config | 1 + .../selftests/bpf/prog_tests/netpoll.c | 92 ++++++++++++++ .../selftests/bpf/progs/netpoll_common.h | 64 ++++++++++ .../selftests/bpf/progs/netpoll_sanity.c | 118 ++++++++++++++++++ 4 files changed, 275 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/netpoll.c create mode 100644 tools/testing/selftests/bpf/progs/netpoll_common.h create mode 100644 tools/testing/selftests/bpf/progs/netpoll_sanity.c
tools/testing/selftests/bpf/config +1 -0
@@ -7,6 +7,7 @@ CONFIG_BPF_JIT=y CONFIG_BPF_KPROBE_OVERRIDE=y CONFIG_BPF_LIRC_MODE2=y CONFIG_BPF_LSM=y +CONFIG_BPF_NETPOLL=y CONFIG_BPF_STREAM_PARSER=y CONFIG_BPF_SYSCALL=y # CONFIG_BPF_UNPRIV_DEFAULT_OFF is not set
tools/testing/selftests/bpf/prog_tests/netpoll.c new file +92 -0
92 lines not on this page · raw message
tools/testing/selftests/bpf/progs/netpoll_common.h new file +64 -0
64 lines not on this page · raw message
tools/testing/selftests/bpf/progs/netpoll_sanity.c new file +118 -0
118 lines not on this page · raw message
Signature · 1 line
2.34.1
RFC PATCH 3/4 selftests/bpf: Add netpoll kfunc IPv6 variant test
In reply to Mahe TardyAdd a selftest that exercises the bpf_netpoll kfuncs end-to-end with IPv6, reusing the code that was added for IPv4.
--- .../selftests/bpf/prog_tests/netpoll.c | 43 +++++++++++++++---- .../selftests/bpf/progs/netpoll_sanity.c | 33 ++++++++++---- 2 files changed, 59 insertions(+), 17 deletions(-)
tools/testing/selftests/bpf/prog_tests/netpoll.c +34 -9
@@ -9,15 +9,20 @@#include "netpoll_sanity.skel.h" #define NS_TEST "netpoll_sanity_ns" +#define NS_TEST_V6 "netpoll_sanity_ns_v6"#define DUMMY_DEV "dummy0"#define DUMMY_IP "10.0.0.1"#define REMOTE_IP "10.0.0.2" +#define DUMMY_IP6 "fd00::1" +#define REMOTE_IP6 "fd00::2" -void test_netpoll_sanity (void ) +static void run_netpoll_test (const char *ns_name,const char *local_ip, +const char *remote_ip,bool ipv6) {LIBBPF_OPTS (bpf_test_run_opts, opts);struct nstoken *nstoken =NULL ;struct netpoll_sanity *skel; +struct in6_addr addr6;int err, pfd, fd; skel =netpoll_sanity__open_and_load ();
@@ -25,18 +30,28 @@ void test_netpoll_sanity(void)return ;/* Create a network namespace with a dummy device */ -SYS (fail,"ip netns add %s" ,NS_TEST ); -SYS (fail,"ip -net %s link add %s type dummy" ,NS_TEST ,DUMMY_DEV ); -SYS (fail,"ip -net %s addr add %s/24 dev %s" ,NS_TEST ,DUMMY_IP ,DUMMY_DEV ); -SYS (fail,"ip -net %s link set %s up" ,NS_TEST ,DUMMY_DEV ); - - nstoken =open_netns (NS_TEST ); +SYS (fail,"ip netns add %s" , ns_name); +SYS (fail,"ip -net %s link add %s type dummy" , ns_name,DUMMY_DEV ); +if (ipv6) +SYS (fail,"ip -net %s addr add %s/64 dev %s" , ns_name, local_ip,DUMMY_DEV ); +else +SYS (fail,"ip -net %s addr add %s/24 dev %s" , ns_name, local_ip,DUMMY_DEV ); +SYS (fail,"ip -net %s link set %s up" , ns_name,DUMMY_DEV ); + + nstoken =open_netns (ns_name);if (!ASSERT_OK_PTR (nstoken,"open_netns" )) goto fail;/* Configure the BPF program globals */ snprintf (skel->bss->dev_name,sizeof (skel->bss->dev_name),"%s" ,DUMMY_DEV ); - skel->bss->remote_ip =inet_addr (REMOTE_IP ); +if (ipv6) { +if (inet_pton (AF_INET6 , remote_ip, &addr6) !=1 ) + goto fail; +__builtin_memcpy (&skel->bss->remote_ip6, &addr6,sizeof (addr6)); + skel->bss->ipv6 =1 ; + }else { + skel->bss->remote_ip =inet_addr (remote_ip); + } skel->bss->local_port =5555 ; skel->bss->remote_port =6666 ; skel->bss->remote_mac[0 ] =0xaa ;
@@ -87,6 +102,16 @@ void test_netpoll_sanity(void) fail:if (nstoken)close_netns (nstoken); -SYS_NOFAIL ("ip netns del " NS_TEST " &> /dev/null" ); +SYS_NOFAIL ("ip netns del %s &> /dev/null" , ns_name);netpoll_sanity__destroy (skel); } + +void test_netpoll_sanity (void ) +{ +run_netpoll_test (NS_TEST ,DUMMY_IP ,REMOTE_IP , false); +} + +void test_netpoll_sanity_ipv6 (void ) +{ +run_netpoll_test (NS_TEST_V6 ,DUMMY_IP6 ,REMOTE_IP6 , true); +}
tools/testing/selftests/bpf/progs/netpoll_sanity.c +25 -8
@@ -12,9 +12,11 @@/* Globals for passing config from userspace */ char dev_name[16 ] = {};__be32 remote_ip; +struct in6_addr remote_ip6;__u16 local_port;__u16 remote_port;__u8 remote_mac[6 ] = {}; +int ipv6;/* Results */ int status;
@@ -35,10 +37,14 @@ int netpoll_setup_test(void *ctx) status =0 ;__builtin_memcpy (opts.dev_name, dev_name,16 ); - opts.remote_ip = remote_ip; +if (ipv6) +__builtin_memcpy (&opts.remote_ip6, &remote_ip6,sizeof (remote_ip6)); +else + opts.remote_ip = remote_ip; opts.local_port = local_port; opts.remote_port = remote_port;__builtin_memcpy (opts.remote_mac, remote_mac,6 ); + opts.ipv6 = ipv6; bnp =bpf_netpoll_create (&opts,sizeof (opts), &err);if (!bnp) {
@@ -88,7 +94,9 @@ int BPF_PROG(netpoll_dummy_xmit, struct sk_buff *skb, struct net_device *dev)unsigned char *data;struct ethhdr eth;struct iphdr ip; +struct ipv6hdr ip6;struct udphdr udp; +unsigned int offset;if (bpf_probe_read_kernel (&data,sizeof (data), &skb->data) <0 )return 0 ;
@@ -97,19 +105,28 @@ int BPF_PROG(netpoll_dummy_xmit, struct sk_buff *skb, struct net_device *dev)if (bpf_probe_read_kernel (ð,sizeof (eth), data) <0 )return 0 ; -if (eth.h_proto !=bpf_htons (ETH_P_IP )) -return 0 ; -if (bpf_probe_read_kernel (&ip,sizeof (ip), data +sizeof (struct ethhdr )) <0 ) -return 0 ; -if (ip.protocol !=IPPROTO_UDP ) +if (eth.h_proto ==bpf_htons (ETH_P_IP )) { +if (bpf_probe_read_kernel (&ip,sizeof (ip), data +sizeof (struct ethhdr )) <0 ) +return 0 ; +if (ip.protocol !=IPPROTO_UDP ) +return 0 ; + offset =sizeof (struct ethhdr ) + (ip.ihl *4 ); + }else if (eth.h_proto ==bpf_htons (ETH_P_IPV6 )) { +if (bpf_probe_read_kernel (&ip6,sizeof (ip6), data +sizeof (struct ethhdr )) <0 ) +return 0 ; +if (ip6.nexthdr !=IPPROTO_UDP ) +return 0 ; + offset =sizeof (struct ethhdr ) +sizeof (struct ipv6hdr ); + }else {return 0 ; + } -if (bpf_probe_read_kernel (&udp,sizeof (udp), data +sizeof (struct ethhdr ) + (ip.ihl *4 )) <0 ) +if (bpf_probe_read_kernel (&udp,sizeof (udp), data + offset) <0 )return 0 ;if (udp.dest !=bpf_htons (remote_port))return 0 ; -if (bpf_probe_read_kernel (&driver_xmit,sizeof (driver_xmit), data +sizeof (struct ethhdr ) + (ip.ihl *4 ) +sizeof (struct udphdr )) <0 ) +if (bpf_probe_read_kernel (&driver_xmit,sizeof (driver_xmit), data + offset +sizeof (struct udphdr )) <0 )return 0 ;return 0 ;
Signature · 1 line
2.34.1
RFC PATCH 4/4 selftests/bpf: Add netpoll setup basic tests
In reply to Mahe TardyAdd a pair of BPF progs, netpoll_release and netpoll_acquire to test that the respective bpf_netpoll_release and bpf_netpoll_acquire behave as expected and that the verifier has been configured to catch unreleased references.
--- .../selftests/bpf/prog_tests/netpoll.c | 23 +++++++++ .../selftests/bpf/progs/netpoll_basic.c | 47 +++++++++++++++++++ 2 files changed, 70 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/netpoll_basic.c
tools/testing/selftests/bpf/prog_tests/netpoll.c +23 -0
@@ -7,15 +7,38 @@#include "test_progs.h" #include "network_helpers.h" #include "netpoll_sanity.skel.h" +#include "netpoll_basic.skel.h" #define NS_TEST "netpoll_sanity_ns"#define NS_TEST_V6 "netpoll_sanity_ns_v6" +#define NS_BASIC_TEST "netpoll_basic_ns"#define DUMMY_DEV "dummy0"#define DUMMY_IP "10.0.0.1"#define REMOTE_IP "10.0.0.2"#define DUMMY_IP6 "fd00::1"#define REMOTE_IP6 "fd00::2" +void test_netpoll_basic (void ) +{ +struct nstoken *nstoken =NULL ; + +SYS (fail,"ip netns add %s" ,NS_BASIC_TEST ); +SYS (fail,"ip -net %s link add %s type dummy" ,NS_BASIC_TEST ,DUMMY_DEV ); +SYS (fail,"ip -net %s addr add %s/24 dev %s" ,NS_BASIC_TEST ,DUMMY_IP ,DUMMY_DEV ); +SYS (fail,"ip -net %s link set %s up" ,NS_BASIC_TEST ,DUMMY_DEV ); + + nstoken =open_netns (NS_BASIC_TEST ); +if (!ASSERT_OK_PTR (nstoken,"open_netns" )) + goto fail; + +RUN_TESTS (netpoll_basic); + +fail: +if (nstoken) +close_netns (nstoken); +SYS_NOFAIL ("ip netns del %s &> /dev/null" ,NS_BASIC_TEST ); +} +static void run_netpoll_test (const char *ns_name,const char *local_ip,const char *remote_ip,bool ipv6) {
tools/testing/selftests/bpf/progs/netpoll_basic.c new file +47 -0
47 lines not on this page · raw message
Signature · 1 line
2.34.1
Jakub Kicinski
maintainerQuoted 16 lines · On Mon, 9 Mar 2026 13:16:31 +0000 Mahe Tardy wrote:
This patch series introduces
bpf_netpoll, a set of BPF kfuncs that allow BPF programs to send UDP packets via the netpoll infrastructure. This provides a mechanism for BPF programs (e.g., LSM hooks) to emit telemetry over UDP without depending on the regular networking stack.For reference, this was discussed at LSF/MM/BPF 2025[^1] in Montreal, and again at Plumbers 2025 in Tokyo. Liam Wisehart mentioned this work during his presentation of BpfJailer[^2].
The main use case is to be able to completely dispense with agents/daemons for BPF programs after startup. In the case of Isovalent's Tetragon, the idea would be to be able to emit security alerts or export data from BPF even when the agent is down. For meta, according to Liam presentation[^2], this could replace logging via ringbuffers which created cross-binary versioning issues.
Quoted 8 lines
The implementation follows the established kfunc lifecycle pattern (create/acquire/release with refcounting, kptr map storage, dtor registration), for example used by the network
bpf_cryptokfuncs.Further patches would extend the
bpf_netpoll_sendkfunc to more program types. Note that network program types should not encounter recursion issues as netpoll bypasses the network stack and sends directly to the driver.
netpoll is a fairly constrained and tricky vehicle for sending data out. Its built to export logs and crash info, not arbitrary (potentially high rate) logs.
Plus you will still need user space components in any modern deployments to establish security associations and/or add some sort of "security proxy".
Long story short this may be a fun PoC to vibe code but architecturally having a standard-ish exporter or something integrated with systemd seems like a much better system architecture.
Martin KaFai Lau
reviewerQuoted 16 lines · Mahe Tardy
This patch series introduces
bpf_netpoll, a set of BPF kfuncs that allow BPF programs to send UDP packets via the netpoll infrastructure. This provides a mechanism for BPF programs (e.g., LSM hooks) to emit telemetry over UDP without depending on the regular networking stack.For reference, this was discussed at LSF/MM/BPF 2025[^1] in Montreal, and again at Plumbers 2025 in Tokyo. Liam Wisehart mentioned this work during his presentation of BpfJailer[^2].
The main use case is to be able to completely dispense with agents/daemons for BPF programs after startup. In the case of Isovalent's Tetragon, the idea would be to be able to emit security alerts or export data from BPF even when the agent is down. For meta, according to Liam presentation[^2], this could replace logging via ringbuffers which created cross-binary versioning issues.
Quoted 8 lines
The implementation follows the established kfunc lifecycle pattern (create/acquire/release with refcounting, kptr map storage, dtor registration), for example used by the network
bpf_cryptokfuncs.Further patches would extend the
bpf_netpoll_sendkfunc to more program types. Note that network program types should not encounter recursion issues as netpoll bypasses the network stack and sends directly to the driver.
netpoll may be an easy replacement for bpf_ringbuf_output, which can be used in different running contexts. If it is to replace the user space daemon in production, it loses too many things from the networking stack: routing, tc, etc. It could escape the current tc/tracing bpf prog, monitoring, QoS marking, qdisc, etc. There is still the encryption piece as well.
Song Liu
reviewerHi Martin and Jakub,
Thanks for your comments.
Quoted 27 lines · Martin KaFai Lau
Quoted 16 lines · Mahe Tardy
This patch series introduces
bpf_netpoll, a set of BPF kfuncs that allow BPF programs to send UDP packets via the netpoll infrastructure. This provides a mechanism for BPF programs (e.g., LSM hooks) to emit telemetry over UDP without depending on the regular networking stack.For reference, this was discussed at LSF/MM/BPF 2025[^1] in Montreal, and again at Plumbers 2025 in Tokyo. Liam Wisehart mentioned this work during his presentation of BpfJailer[^2].
The main use case is to be able to completely dispense with agents/daemons for BPF programs after startup. In the case of Isovalent's Tetragon, the idea would be to be able to emit security alerts or export data from BPF even when the agent is down. For meta, according to Liam presentation[^2], this could replace logging via ringbuffers which created cross-binary versioning issues.
Quoted 8 lines
The implementation follows the established kfunc lifecycle pattern (create/acquire/release with refcounting, kptr map storage, dtor registration), for example used by the network
bpf_cryptokfuncs.Further patches would extend the
bpf_netpoll_sendkfunc to more program types. Note that network program types should not encounter recursion issues as netpoll bypasses the network stack and sends directly to the driver.
Quoted 6 lines
netpoll may be an easy replacement for
bpf_ringbuf_output, which can be used in different running contexts. If it is to replace the user space daemon in production, it loses too many things from the networking
stack: routing, tc, etc. It could escape the current tc/tracing bpf prog, monitoring, QoS marking, qdisc, etc. There is still the encryption piece as well.
netpoll kfuncs alone are not enough to make a good solution. However, I wonder whether these kfuncs can be useful building blocks to enable good enough solutions for some use cases. These solutions should include kfuncs, bpf-c components, and user space components. Specifically, the user space components can handle security handshake, and the bpf-c component can provide basic rate limit logic. If we can create a library with the bpf-c and userspace components, would it make a useful solution for some use cases (data rate not too high, etc.). Or does it still miss some essential capabilities?
Thanks,
Song