* [PATCH bpf-next v7 2/2] selftests/bpf: Test ksock connect/send calls from wq
2026-10-16 13:33 [PATCH bpf-next v7 1/2] bpf: Allow ksock connect/send calls from wq Mahe Tardy
@ 2026-10-16 13:33 ` Mahe Tardy
2026-10-16 17:00 ` [PATCH bpf-next v7 1/2] bpf: Allow " patchwork-bot+netdevbpf
1 sibling, 0 replies; 3+ messages in thread
From: Mahe Tardy @ 2026-10-16 13:33 UTC (permalink / raw)
To: bpf
Cc: andrii, ast, daniel, davem, eddyz87, edumazet, john.fastabend,
kuba, liamwisehart, martin.lau, pabeni, song, netdev, sdf.kernel,
ameryhung, kuniyu, memxor, jiayuan.chen, almagui, Mahe Tardy
Extend test_ksock_wq() added in 'c93cbdb13f99 ("selftests/bpf: Add ksock
test for async callback guard")' to test that the bpf_ksock_connect()
and bpf_ksock_send() kfuncs are now allowed and work when called from
workqueues.
Tested-by: Alan Maguire (Oracle) <almagui@kernel.org>
Signed-off-by: Mahe Tardy <mahe.tardy@gmail.com>
---
.../selftests/bpf/prog_tests/ksock_wq.c | 29 +++++--
tools/testing/selftests/bpf/progs/ksock_wq.c | 80 ++++++++++++++++---
2 files changed, 95 insertions(+), 14 deletions(-)
diff --git a/tools/testing/selftests/bpf/prog_tests/ksock_wq.c b/tools/testing/selftests/bpf/prog_tests/ksock_wq.c
index d6dc20b8f95b..12c2275e8177 100644
--- a/tools/testing/selftests/bpf/prog_tests/ksock_wq.c
+++ b/tools/testing/selftests/bpf/prog_tests/ksock_wq.c
@@ -4,6 +4,7 @@
#include <unistd.h>
#include "test_progs.h"
+#include "network_helpers.h"
#include "ksock_wq.skel.h"
#define CALLBACK_WAIT_RETRIES 1000
@@ -13,13 +14,22 @@ void test_ksock_wq(void)
{
LIBBPF_OPTS(bpf_test_run_opts, opts);
struct ksock_wq *skel;
+ char recv_data[sizeof(skel->data->send_data)];
u32 callback_done;
- int err, i;
+ int err, i, port, rfd;
skel = ksock_wq__open_and_load();
if (!ASSERT_OK_PTR(skel, "ksock_wq open and load"))
return;
+ rfd = start_server(AF_INET, SOCK_DGRAM, "127.0.0.1", 0, 1000);
+ if (!ASSERT_OK_FD(rfd, "receiver socket"))
+ goto out;
+ port = get_socket_local_port(rfd);
+ if (!ASSERT_GE(port, 0, "receiver port"))
+ goto out;
+ skel->bss->remote_port = port;
+
err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.ksock_wq_start),
&opts);
if (!ASSERT_OK(err, "run ksock_wq_start"))
@@ -28,18 +38,27 @@ void test_ksock_wq(void)
goto out;
for (i = 0; i < CALLBACK_WAIT_RETRIES; i++) {
- if (__atomic_load_n(&skel->bss->callback_done, __ATOMIC_ACQUIRE))
+ if (__atomic_load_n(&skel->bss->callback_done, __ATOMIC_ACQUIRE) == 2)
break;
usleep(CALLBACK_WAIT_US);
}
callback_done = __atomic_load_n(&skel->bss->callback_done,
__ATOMIC_ACQUIRE);
- if (!ASSERT_EQ(callback_done, 1, "workqueue callback completed"))
+ if (!ASSERT_EQ(callback_done, 2, "workqueue callbacks completed"))
goto out;
- ASSERT_EQ(skel->bss->create_err, -EOPNOTSUPP,
- "workqueue create rejected");
+ ASSERT_EQ(skel->bss->create_ret, -EOPNOTSUPP, "workqueue create rejected");
+
+ if (!ASSERT_EQ(skel->bss->connect_send_ret, sizeof(recv_data),
+ "workqueue send bytes"))
+ goto out;
+ err = recv(rfd, recv_data, sizeof(recv_data), 0);
+ if (ASSERT_EQ(err, sizeof(recv_data), "recv len"))
+ ASSERT_MEMEQ(recv_data, skel->data->send_data, sizeof(recv_data),
+ "payload match");
out:
+ if (rfd >= 0)
+ close(rfd);
ksock_wq__destroy(skel);
}
diff --git a/tools/testing/selftests/bpf/progs/ksock_wq.c b/tools/testing/selftests/bpf/progs/ksock_wq.c
index 16a1873d132e..fab356252d53 100644
--- a/tools/testing/selftests/bpf/progs/ksock_wq.c
+++ b/tools/testing/selftests/bpf/progs/ksock_wq.c
@@ -2,6 +2,7 @@
/* Copyright (c) 2026 Isovalent */
#include "vmlinux.h"
+#include <bpf/bpf_endian.h>
#include <bpf/bpf_helpers.h>
#include "bpf_experimental.h"
#include "bpf_tracing_net.h"
@@ -14,15 +15,19 @@ struct ksock_wq_value {
struct {
__uint(type, BPF_MAP_TYPE_ARRAY);
- __uint(max_entries, 1);
+ __uint(max_entries, 2);
__type(key, u32);
__type(value, struct ksock_wq_value);
} work_map SEC(".maps");
-int create_err;
+char send_data[] = "hello from bpf workqueue";
+
+__be16 remote_port;
+int connect_send_ret;
+int create_ret;
u32 callback_done;
-static int ksock_wq_callback(void *map, int *key, void *value)
+static int ksock_wq_create_cb(void *map, int *key, void *value)
{
struct bpf_ksock_create_opts opts = {
.family = AF_INET,
@@ -35,28 +40,85 @@ static int ksock_wq_callback(void *map, int *key, void *value)
ks = bpf_ksock_create(&opts, sizeof(opts), &err);
if (ks)
bpf_ksock_release(ks);
- create_err = err;
+ create_ret = err;
__sync_fetch_and_add(&callback_done, 1);
return 0;
}
-SEC("syscall")
-int ksock_wq_start(void *ctx)
+static int ksock_wq_connect_send_cb(void *map, int *key, void *value)
+{
+ union bpf_ksock_addr addr = {
+ .sin = {
+ .sin_family = AF_INET,
+ .sin_port = remote_port,
+ .sin_addr.s_addr = bpf_htonl(0x7f000001),
+ },
+ };
+ struct bpf_ksock *ks;
+ int err = -ENOENT;
+
+ ks = ksock_ctx_get();
+ if (!ks)
+ goto out;
+ err = bpf_ksock_connect(ks, &addr, sizeof(addr));
+ if (!err)
+ err = bpf_ksock_send(ks, send_data, sizeof(send_data));
+ bpf_ksock_release(ks);
+out:
+ connect_send_ret = err;
+ __sync_fetch_and_add(&callback_done, 1);
+ return 0;
+}
+
+static int wq_set_callback_start(int (*callback_fn)(void *, int *, void *), u32 key)
{
struct ksock_wq_value *value;
- u32 key = 0;
int err;
value = bpf_map_lookup_elem(&work_map, &key);
if (!value)
return -ENOENT;
+
err = bpf_wq_init(&value->work, &work_map, 0);
if (err)
return err;
- err = bpf_wq_set_callback(&value->work, ksock_wq_callback, 0);
+ err = bpf_wq_set_callback(&value->work, callback_fn, 0);
+ if (err)
+ return err;
+ err = bpf_wq_start(&value->work, 0);
if (err)
return err;
- return bpf_wq_start(&value->work, 0);
+
+ return 0;
+}
+
+SEC("syscall")
+int ksock_wq_start(void *ctx)
+{
+ struct bpf_ksock_create_opts opts = {
+ .family = AF_INET,
+ .type = SOCK_DGRAM,
+ .protocol = IPPROTO_UDP,
+ };
+ struct bpf_ksock *ks;
+ int err = 0;
+
+ ks = bpf_ksock_create(&opts, sizeof(opts), &err);
+ if (!ks)
+ return err;
+ err = ksock_ctx_insert(ks);
+ if (err)
+ return err;
+
+ err = wq_set_callback_start(ksock_wq_connect_send_cb, 0);
+ if (err)
+ return err;
+
+ err = wq_set_callback_start(ksock_wq_create_cb, 1);
+ if (err)
+ return err;
+
+ return 0;
}
char __license[] SEC("license") = "GPL";
--
2.43.0
^ permalink raw reply related [flat|nested] 3+ messages in thread* Re: [PATCH bpf-next v7 1/2] bpf: Allow ksock connect/send calls from wq
2026-10-16 13:33 [PATCH bpf-next v7 1/2] bpf: Allow ksock connect/send calls from wq Mahe Tardy
2026-10-16 13:33 ` [PATCH bpf-next v7 2/2] selftests/bpf: Test " Mahe Tardy
@ 2026-10-16 17:00 ` patchwork-bot+netdevbpf
1 sibling, 0 replies; 3+ messages in thread
From: patchwork-bot+netdevbpf @ 2026-10-16 17:00 UTC (permalink / raw)
To: Mahe Tardy
Cc: bpf, andrii, ast, daniel, davem, eddyz87, edumazet,
john.fastabend, kuba, liamwisehart, martin.lau, pabeni, song,
netdev, sdf.kernel, ameryhung, kuniyu, memxor, jiayuan.chen,
almagui
Hello:
This series was applied to bpf/bpf-next.git (master)
by Alexei Starovoitov <ast@kernel.org>:
On Fri, 16 Oct 2026 13:33:17 +0000 you wrote:
> The initial ksock implementation, commit 7ae4eb14c5f9 ("bpf: Add ksock
> kfuncs"), kept LSM checks from the kfunc calls and disallowed
> asynchronous workqueues because worker credentials differ from those of
> the triggering task. However, discussions at Plumbers 2026[^1] revealed
> that bypassing LSM checks for BPF-created sockets could be acceptable.
>
> This patch allows workqueue use while retaining LSM checks for now,
> paving the way to call bpf_ksock_connect() and bpf_ksock_send() from
> non-sleepable programs, such as tracing programs, in future patches.
>
> [...]
Here is the summary with links:
- [bpf-next,v7,1/2] bpf: Allow ksock connect/send calls from wq
https://git.kernel.org/bpf/bpf-next/c/60bbe76a3f9e
- [bpf-next,v7,2/2] selftests/bpf: Test ksock connect/send calls from wq
https://git.kernel.org/bpf/bpf-next/c/242d8416f60c
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply [flat|nested] 3+ messages in thread