mirror of
https://github.com/torvalds/linux.git
synced 2026-09-23 13:14:02 +02:00
selftests/bpf: Add kfunc __arena and __arena__nullable argument tests
Add arena-argument kfuncs to bpf_testmod, which also exercises the argument rebasing on module kfuncs, and tests covering the accepted argument forms (arena pointer, low 32 bits as a scalar, full user address as a scalar), the exact rebase semantics via capture kfuncs returning the raw argument (zero low 32 bits arrive as the arena kernel base under __arena and as NULL under __arena__nullable), five arena arguments in one call, a mixed __arena plus __arena__nullable call exercising both bitmasks on one call site, a kernel-side dereference of an unpopulated page recovering through the scratch page, and the rejections (no arena in the program, incompatible register type). The tests run on x86-64 and skip elsewhere, as programs with arena-tagged kfunc args fail verification where the JIT lacks support. Signed-off-by: Tejun Heo <tj@kernel.org> Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com> Acked-by: Eduard Zingerman <eddyz87@gmail.com> Link: https://patch.msgid.link/20260808003938.3486067-9-memxor@gmail.com Signed-off-by: Eduard Zingerman <eddyz87@gmail.com>
This commit is contained in:
Tejun Heo
Eduard Zingerman
parent
5129e9be21
commit
0996e93691
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include <test_progs.h>
|
||||
|
||||
#include "arena_kfunc.skel.h"
|
||||
#include "cap_helpers.h"
|
||||
#include "verifier_align.skel.h"
|
||||
#include "verifier_and.skel.h"
|
||||
|
|
@ -162,6 +163,8 @@ static void run_tests_aux(const char *skel_name,
|
|||
|
||||
#define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL)
|
||||
|
||||
void test_arena_kfunc(void) { RUN_TESTS(arena_kfunc); }
|
||||
|
||||
void test_verifier_align(void) { RUN(verifier_align); }
|
||||
void test_verifier_and(void) { RUN(verifier_and); }
|
||||
void test_verifier_arena(void) { RUN(verifier_arena); }
|
||||
|
|
|
|||
234
tools/testing/selftests/bpf/progs/arena_kfunc.c
Normal file
234
tools/testing/selftests/bpf/progs/arena_kfunc.c
Normal file
|
|
@ -0,0 +1,234 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
|
||||
|
||||
#define BPF_NO_KFUNC_PROTOTYPES
|
||||
#include <vmlinux.h>
|
||||
#include <bpf/bpf_helpers.h>
|
||||
#include "bpf_misc.h"
|
||||
#include "bpf_experimental.h"
|
||||
#include <bpf_arena_common.h>
|
||||
#include "../test_kmods/bpf_testmod_kfunc.h"
|
||||
|
||||
struct {
|
||||
__uint(type, BPF_MAP_TYPE_ARENA);
|
||||
__uint(map_flags, BPF_F_MMAPABLE);
|
||||
/* page 0 hosts the arena global, page 1 is for allocations */
|
||||
__uint(max_entries, 2);
|
||||
} arena SEC(".maps");
|
||||
|
||||
/*
|
||||
* Occupies page 0 so no allocation lands at arena offset 0, which the
|
||||
* nullable tests below must be able to tell apart from NULL.
|
||||
*/
|
||||
u64 __arena arena_pad;
|
||||
|
||||
/* volatile to force the scalar reloads below */
|
||||
volatile u64 stash;
|
||||
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__success __retval(0)
|
||||
int arena_arg_forms(void *ctx)
|
||||
{
|
||||
#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
|
||||
u64 __arena *val;
|
||||
u64 ret;
|
||||
|
||||
val = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
if (!val)
|
||||
return 1;
|
||||
|
||||
/* PTR_TO_ARENA argument */
|
||||
*val = 41;
|
||||
ret = bpf_kfunc_arena_arg_test((u64 *)val);
|
||||
if (ret != 41 || *val != 42)
|
||||
return 2;
|
||||
|
||||
/* the low 32 bits as a scalar */
|
||||
stash = (u32)(u64)val;
|
||||
ret = bpf_kfunc_arena_arg_test((u64 *)stash);
|
||||
if (ret != 42 || *val != 43)
|
||||
return 3;
|
||||
|
||||
/* the full user address as a scalar */
|
||||
stash = (u64)val;
|
||||
bpf_addr_space_cast(stash, 1, 0);
|
||||
ret = bpf_kfunc_arena_arg_test((u64 *)stash);
|
||||
if (ret != 43 || *val != 44)
|
||||
return 4;
|
||||
|
||||
bpf_arena_free_pages(&arena, (void __arena *)val, 1);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Pin the rebase semantics using the capture kfuncs, which return the raw
|
||||
* argument value: __arena rebases unconditionally, so zero low 32 bits
|
||||
* arrive as the arena kernel base, while __arena__nullable turns them into
|
||||
* NULL.
|
||||
*/
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__success __retval(0)
|
||||
int arena_arg_rebase(void *ctx)
|
||||
{
|
||||
#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
|
||||
u64 __arena *val;
|
||||
u64 base, off;
|
||||
|
||||
val = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
if (!val)
|
||||
return 1;
|
||||
|
||||
base = bpf_kfunc_arena_cap_test(NULL);
|
||||
if (!base)
|
||||
return 2;
|
||||
|
||||
/* only the low 32 bits contribute */
|
||||
stash = 0xbadc0ffe00000000;
|
||||
if (bpf_kfunc_arena_cap_test((u64 *)stash) != base)
|
||||
return 3;
|
||||
|
||||
off = (u32)(u64)val;
|
||||
if (bpf_kfunc_arena_cap_test((u64 *)val) != base + off)
|
||||
return 4;
|
||||
|
||||
if (bpf_kfunc_arena_cap_nullable_test(NULL) != 0)
|
||||
return 5;
|
||||
|
||||
stash = 0xbadc0ffe00000000;
|
||||
if (bpf_kfunc_arena_cap_nullable_test((u64 *)stash) != 0)
|
||||
return 6;
|
||||
|
||||
if (bpf_kfunc_arena_cap_nullable_test((u64 *)val) != base + off)
|
||||
return 7;
|
||||
|
||||
bpf_arena_free_pages(&arena, (void __arena *)val, 1);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__success __retval(0)
|
||||
int arena_args5(void *ctx)
|
||||
{
|
||||
#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
|
||||
u64 __arena *val;
|
||||
|
||||
val = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
if (!val)
|
||||
return 1;
|
||||
|
||||
val[0] = 1;
|
||||
val[1] = 2;
|
||||
val[2] = 4;
|
||||
val[3] = 8;
|
||||
val[4] = 16;
|
||||
|
||||
if (bpf_kfunc_arena_args5_test((u64 *)&val[0], (u64 *)&val[1],
|
||||
(u64 *)&val[2], (u64 *)&val[3],
|
||||
(u64 *)&val[4]) != 31)
|
||||
return 2;
|
||||
if (bpf_kfunc_arena_args5_test((u64 *)&val[0], (u64 *)&val[1],
|
||||
(u64 *)&val[2], (u64 *)&val[3], NULL) != 15)
|
||||
return 3;
|
||||
|
||||
bpf_arena_free_pages(&arena, (void __arena *)val, 1);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__success __retval(0)
|
||||
int arena_arg_mixed(void *ctx)
|
||||
{
|
||||
#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
|
||||
u64 __arena *val;
|
||||
|
||||
val = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
if (!val)
|
||||
return 1;
|
||||
|
||||
val[0] = 7;
|
||||
val[1] = 5;
|
||||
|
||||
if (bpf_kfunc_arena_mixed_test((u64 *)&val[0], NULL) != 7)
|
||||
return 2;
|
||||
|
||||
if (bpf_kfunc_arena_mixed_test((u64 *)&val[0], (u64 *)&val[1]) != 12)
|
||||
return 3;
|
||||
|
||||
bpf_arena_free_pages(&arena, (void __arena *)val, 1);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* kernel-side faults on unpopulated pages recover via the scratch page */
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__success __retval(0)
|
||||
int arena_arg_unpopulated(void *ctx)
|
||||
{
|
||||
#if defined(__BPF_FEATURE_ADDR_SPACE_CAST)
|
||||
u64 __arena *val;
|
||||
|
||||
val = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
if (!val)
|
||||
return 1;
|
||||
|
||||
stash = (u64)val + PAGE_SIZE;
|
||||
bpf_kfunc_arena_arg_test((u64 *)stash);
|
||||
|
||||
bpf_arena_free_pages(&arena, (void __arena *)val, 1);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__failure __msg("arena pointer requires a program with an associated arena")
|
||||
int arena_arg_no_arena(void *ctx)
|
||||
{
|
||||
bpf_kfunc_arena_arg_test((u64 *)1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__failure __msg("is not a pointer to arena or scalar")
|
||||
int arena_arg_bad_reg(void *ctx)
|
||||
{
|
||||
u64 buf = 0;
|
||||
|
||||
/* use the arena so the program passes the arena presence check */
|
||||
bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
bpf_kfunc_arena_arg_test(&buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if defined(__BPF_FEATURE_ADDR_SPACE_CAST) && \
|
||||
defined(__BPF_FEATURE_STACK_ARGUMENT)
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__failure __msg("arena pointer cannot be a stack argument")
|
||||
int arena_arg_stack(void *ctx)
|
||||
{
|
||||
bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
|
||||
bpf_kfunc_arena_stack_arg_test(1, 2, 3, 4, 5, (u64 *)1);
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
SEC("syscall")
|
||||
__arch_x86_64
|
||||
__description("arena_arg_stack: not supported, dummy test")
|
||||
__success
|
||||
int arena_arg_stack(void *ctx)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
char _license[] SEC("license") = "GPL";
|
||||
|
|
@ -237,6 +237,44 @@ __bpf_kfunc void bpf_kfunc_common_test(void)
|
|||
{
|
||||
}
|
||||
|
||||
__bpf_kfunc u64 bpf_kfunc_arena_arg_test(u64 *val__arena)
|
||||
{
|
||||
u64 old;
|
||||
|
||||
old = *val__arena;
|
||||
*val__arena = old + 1;
|
||||
return old;
|
||||
}
|
||||
|
||||
__bpf_kfunc u64 bpf_kfunc_arena_cap_test(u64 *val__arena)
|
||||
{
|
||||
return (u64)val__arena;
|
||||
}
|
||||
|
||||
__bpf_kfunc u64 bpf_kfunc_arena_cap_nullable_test(u64 *val__arena__nullable)
|
||||
{
|
||||
return (u64)val__arena__nullable;
|
||||
}
|
||||
|
||||
__bpf_kfunc u64 bpf_kfunc_arena_args5_test(u64 *a__arena, u64 *b__arena,
|
||||
u64 *c__arena, u64 *d__arena,
|
||||
u64 *e__arena__nullable)
|
||||
{
|
||||
return *a__arena + *b__arena + *c__arena + *d__arena +
|
||||
(e__arena__nullable ? *e__arena__nullable : 0);
|
||||
}
|
||||
|
||||
__bpf_kfunc u64 bpf_kfunc_arena_stack_arg_test(u64 a, u64 b, u64 c, u64 d, u64 e,
|
||||
u64 *f__arena)
|
||||
{
|
||||
return a + b + c + d + e + *f__arena;
|
||||
}
|
||||
|
||||
__bpf_kfunc u64 bpf_kfunc_arena_mixed_test(u64 *a__arena, u64 *b__arena__nullable)
|
||||
{
|
||||
return *a__arena + (b__arena__nullable ? *b__arena__nullable : 0);
|
||||
}
|
||||
|
||||
__bpf_kfunc void bpf_kfunc_dynptr_test(struct bpf_dynptr *ptr,
|
||||
struct bpf_dynptr *ptr__nullable)
|
||||
{
|
||||
|
|
@ -755,6 +793,12 @@ BTF_ID_FLAGS(func, bpf_iter_testmod_seq_next, KF_ITER_NEXT | KF_RET_NULL)
|
|||
BTF_ID_FLAGS(func, bpf_iter_testmod_seq_destroy, KF_ITER_DESTROY)
|
||||
BTF_ID_FLAGS(func, bpf_iter_testmod_seq_value)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_common_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_arena_arg_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_arena_cap_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_arena_cap_nullable_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_arena_args5_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_arena_stack_arg_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_arena_mixed_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_pass1)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_dynptr_test)
|
||||
BTF_ID_FLAGS(func, bpf_kfunc_nested_acquire_nonzero_offset_test, KF_ACQUIRE)
|
||||
|
|
|
|||
|
|
@ -98,6 +98,15 @@ void bpf_kfunc_call_test_release(struct prog_test_ref_kfunc *p) __ksym;
|
|||
void bpf_kfunc_call_test_ref(struct prog_test_ref_kfunc *p) __ksym;
|
||||
|
||||
void bpf_kfunc_call_test_mem_len_pass1(void *mem, int len) __ksym;
|
||||
__u64 bpf_kfunc_arena_arg_test(__u64 *val__arena) __ksym;
|
||||
__u64 bpf_kfunc_arena_cap_test(__u64 *val__arena) __ksym;
|
||||
__u64 bpf_kfunc_arena_cap_nullable_test(__u64 *val__arena__nullable) __ksym;
|
||||
__u64 bpf_kfunc_arena_args5_test(__u64 *a__arena, __u64 *b__arena,
|
||||
__u64 *c__arena, __u64 *d__arena,
|
||||
__u64 *e__arena__nullable) __ksym;
|
||||
__u64 bpf_kfunc_arena_stack_arg_test(__u64 a, __u64 b, __u64 c, __u64 d, __u64 e,
|
||||
__u64 *f__arena) __ksym;
|
||||
__u64 bpf_kfunc_arena_mixed_test(__u64 *a__arena, __u64 *b__arena__nullable) __ksym;
|
||||
int *bpf_kfunc_call_test_get_rdwr_mem(struct prog_test_ref_kfunc *p, const int rdwr_buf_size) __ksym;
|
||||
int *bpf_kfunc_call_test_get_rdonly_mem(struct prog_test_ref_kfunc *p, const int rdonly_buf_size) __ksym;
|
||||
int *bpf_kfunc_call_test_acq_rdonly_mem(struct prog_test_ref_kfunc *p, const int rdonly_buf_size) __ksym;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user