github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

selftests/bpf: Test ksock connect/send calls from wq

Browse Source 
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.

Signed-off-by: Mahe Tardy <mahe.tardy@gmail.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Tested-by: Alan Maguire (Oracle) <almagui@kernel.org>
Link: https://patch.msgid.link/20261016133318.33999-2-mahe.tardy@gmail.com
This commit is contained in:
Mahe Tardy 2026-10-16 13:33:18 +00:00 committed by Alexei Starovoitov
parent 60bbe76a3f
commit 242d8416f6
No known key found for this signature in database
2 changed files with 99 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
tools/testing/selftests/bpf/prog_tests/ksock_wq.c
View File

@ -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);
}

88
tools/testing/selftests/bpf/progs/ksock_wq.c
View File

@ -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;
}
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;
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, callback_fn, 0);
if (err)
return err;
err = bpf_wq_start(&value->work, 0);
if (err)
return err;
return 0;
}
SEC("syscall")
int ksock_wq_start(void *ctx)
{
struct ksock_wq_value *value;
u32 key = 0;
int err;
struct bpf_ksock_create_opts opts = {
.family = AF_INET,
.type = SOCK_DGRAM,
.protocol = IPPROTO_UDP,
};
struct bpf_ksock *ks;
int err = 0;
value = bpf_map_lookup_elem(&work_map, &key);
if (!value)
return -ENOENT;
err = bpf_wq_init(&value->work, &work_map, 0);
ks = bpf_ksock_create(&opts, sizeof(opts), &err);
if (!ks)
return err;
err = ksock_ctx_insert(ks);
if (err)
return err;
err = bpf_wq_set_callback(&value->work, ksock_wq_callback, 0);
err = wq_set_callback_start(ksock_wq_connect_send_cb, 0);
if (err)
return err;
return bpf_wq_start(&value->work, 0);
err = wq_set_callback_start(ksock_wq_create_cb, 1);
if (err)
return err;
return 0;
}
char __license[] SEC("license") = "GPL";