Add a test that re-enters call_srcu() from a BPF program, exercising the any-context safety of call_srcu() (and thus call_rcu_tasks_trace(), which is call_srcu() on rcu_tasks_trace_srcu_struct).
An fentry program on rcu_segcblist_enqueue() fires in the middle of call_srcu()'s enqueue -- that function is reached from srcu_gp_start_if_needed() with the srcu_data ->lock held. From there the program performs a task-storage delete, whose only deferred work is call_rcu_tasks_trace(), re-entering the enqueue on the same CPU. The triggering thread is pinned to one CPU and matched by TID, so the program fires only for the test's own delete. Without the call_srcu() any-context fix the nested call re-takes the same sdp lock and self-deadlocks (AA); with it the nested __call_srcu() sees interrupts disabled and defers via irq_work, so the delete returns and the test passes. Because it can hang an unfixed kernel, it is meant to run against a kernel carrying the fix. Signed-off-by: Puranjay Mohan <[email protected]> --- .../selftests/bpf/prog_tests/rcu_reentry.c | 58 +++++++++++++++++++ .../testing/selftests/bpf/progs/rcu_reentry.c | 45 ++++++++++++++ 2 files changed, 103 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/rcu_reentry.c create mode 100644 tools/testing/selftests/bpf/progs/rcu_reentry.c diff --git a/tools/testing/selftests/bpf/prog_tests/rcu_reentry.c b/tools/testing/selftests/bpf/prog_tests/rcu_reentry.c new file mode 100644 index 0000000000000..f6ecd93be30f4 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/rcu_reentry.c @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Exercise re-entry into call_srcu() from BPF; see progs/rcu_reentry.c. */ +#define _GNU_SOURCE +#include <sched.h> +#include <sys/syscall.h> +#include <test_progs.h> +#include "rcu_reentry.skel.h" + +static int sys_pidfd_open(pid_t pid, unsigned int flags) +{ + return syscall(__NR_pidfd_open, pid, flags); +} + +void test_rcu_reentry(void) +{ + struct rcu_reentry *skel; + int err, pidfd = -1, map_fd; + __u64 val = 1; + cpu_set_t set; + + skel = rcu_reentry__open_and_load(); + if (!ASSERT_OK_PTR(skel, "skel_open_and_load")) + return; + + err = rcu_reentry__attach(skel); + if (!ASSERT_OK(err, "skel_attach")) + goto out; + + /* Keep the re-entry on a single CPU. */ + CPU_ZERO(&set); + CPU_SET(0, &set); + if (sched_setaffinity(0, sizeof(set), &set)) + perror("sched_setaffinity"); + + pidfd = sys_pidfd_open(getpid(), 0); + if (!ASSERT_GE(pidfd, 0, "pidfd_open")) + goto out; + map_fd = bpf_map__fd(skel->maps.task_stg); + err = bpf_map_update_elem(map_fd, &pidfd, &val, BPF_NOEXIST); + if (!ASSERT_OK(err, "boot_create")) + goto out; + + /* Arm the handler for this thread, then trigger call_rcu_tasks_trace(). */ + skel->bss->target_pid = syscall(__NR_gettid); + err = bpf_map_delete_elem(map_fd, &pidfd); + ASSERT_OK(err, "boot_delete"); + + /* Only Tree SRCU enqueues via rcu_segcblist_enqueue(); skip elsewhere. */ + if (!skel->bss->hits) { + test__skip(); + goto out; + } + ASSERT_EQ(skel->bss->reentered, 1, "reentry_deferred"); +out: + if (pidfd >= 0) + close(pidfd); + rcu_reentry__destroy(skel); +} diff --git a/tools/testing/selftests/bpf/progs/rcu_reentry.c b/tools/testing/selftests/bpf/progs/rcu_reentry.c new file mode 100644 index 0000000000000..d92a927ff51c0 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/rcu_reentry.c @@ -0,0 +1,45 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Re-enter call_srcu() from a BPF program. fentry on rcu_segcblist_enqueue() + * fires inside call_srcu()'s enqueue (reached from srcu_gp_start_if_needed() + * with the srcu_data ->lock held); the handler then calls call_rcu_tasks_trace() + * -- itself call_srcu() on rcu_tasks_trace_srcu_struct -- re-entering the same + * srcu_data on the same CPU. + */ +#include "vmlinux.h" +#include <bpf/bpf_helpers.h> +#include <bpf/bpf_tracing.h> + +char _license[] SEC("license") = "GPL"; + +struct { + __uint(type, BPF_MAP_TYPE_TASK_STORAGE); + __uint(map_flags, BPF_F_NO_PREALLOC); + __type(key, int); + __type(value, __u64); +} task_stg SEC(".maps"); + +int target_pid; +int hits; +int reentered; + +SEC("fentry/rcu_segcblist_enqueue") +int BPF_PROG(reenter) +{ + struct task_struct *cur; + + if (reentered || !target_pid) + return 0; + + cur = bpf_get_current_task_btf(); + if (!cur || cur->pid != target_pid) + return 0; + + /* Re-enter via a task-storage delete, which calls call_rcu_tasks_trace(). */ + __sync_fetch_and_add(&hits, 1); + bpf_task_storage_get(&task_stg, cur, 0, BPF_LOCAL_STORAGE_GET_F_CREATE); + bpf_task_storage_delete(&task_stg, cur); + + reentered = 1; + return 0; +} -- 2.53.0-Meta
