mirrors/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-04-09 01:47:20 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 's390-bpf-fix-bpf_arch_text_poke-with-new_addr-null-again'

Browse Source 
Ilya Leoshkevich says:

====================
s390/bpf: Fix bpf_arch_text_poke() with new_addr == NULL again

This series fixes a regression causing perf on s390 to trigger a kernel
panic.

Patch 1 fixes the issue, patch 2 adds a test to make sure this doesn't
happen again.
====================

Link: https://patch.msgid.link/20250716194524.48109-1-iii@linux.ibm.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
This commit is contained in:
Alexei Starovoitov
2025-07-16 18:32:31 -07:00
parent bf4807c89d d459dbbbfa
commit af90e85307
2 changed files with 76 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
arch/s390/net/bpf_jit_comp.c
View File

@@ -566,7 +566,15 @@ static void bpf_jit_plt(struct bpf_plt *plt, void *ret, void *target)
{
memcpy(plt, &bpf_plt, sizeof(*plt));
plt->ret = ret;
plt->target = target;
/*
* (target == NULL) implies that the branch to this PLT entry was
* patched and became a no-op. However, some CPU could have jumped
* to this PLT entry before patching and may be still executing it.
*
* Since the intention in this case is to make the PLT entry a no-op,
* make the target point to the return label instead of NULL.
*/
plt->target = target ?: ret;
}
/*

67
tools/testing/selftests/bpf/prog_tests/recursive_attach.c
View File

@@ -149,3 +149,70 @@ void test_fentry_attach_btf_presence(void)
fentry_recursive_target__destroy(target_skel);
fentry_recursive__destroy(tracing_skel);
}
static void *fentry_target_test_run(void *arg)
{
for (;;) {
int prog_fd = __atomic_load_n((int *)arg, __ATOMIC_SEQ_CST);
LIBBPF_OPTS(bpf_test_run_opts, topts);
int err;
if (prog_fd == -1)
break;
err = bpf_prog_test_run_opts(prog_fd, &topts);
if (!ASSERT_OK(err, "fentry_target test_run"))
break;
}
return NULL;
}
void test_fentry_attach_stress(void)
{
struct fentry_recursive_target *target_skel = NULL;
struct fentry_recursive *tracing_skel = NULL;
struct bpf_program *prog;
int err, i, tgt_prog_fd;
pthread_t thread;
target_skel = fentry_recursive_target__open_and_load();
if (!ASSERT_OK_PTR(target_skel,
"fentry_recursive_target__open_and_load"))
goto close_prog;
tgt_prog_fd = bpf_program__fd(target_skel->progs.fentry_target);
err = pthread_create(&thread, NULL,
fentry_target_test_run, &tgt_prog_fd);
if (!ASSERT_OK(err, "bpf_program__set_attach_target"))
goto close_prog;
for (i = 0; i < 1000; i++) {
tracing_skel = fentry_recursive__open();
if (!ASSERT_OK_PTR(tracing_skel, "fentry_recursive__open"))
goto stop_thread;
prog = tracing_skel->progs.recursive_attach;
err = bpf_program__set_attach_target(prog, tgt_prog_fd,
"fentry_target");
if (!ASSERT_OK(err, "bpf_program__set_attach_target"))
goto stop_thread;
err = fentry_recursive__load(tracing_skel);
if (!ASSERT_OK(err, "fentry_recursive__load"))
goto stop_thread;
err = fentry_recursive__attach(tracing_skel);
if (!ASSERT_OK(err, "fentry_recursive__attach"))
goto stop_thread;
fentry_recursive__destroy(tracing_skel);
tracing_skel = NULL;
}
stop_thread:
__atomic_store_n(&tgt_prog_fd, -1, __ATOMIC_SEQ_CST);
err = pthread_join(thread, NULL);
ASSERT_OK(err, "pthread_join");
close_prog:
fentry_recursive__destroy(tracing_skel);
fentry_recursive_target__destroy(target_skel);
}