8e9af82171
Move all kfunc exports into separate bpf_testmod_kfunc.h header file and include it in tests that need it. We will move all test kfuncs into bpf_testmod in following change, so it's convenient to have declarations in single place. The bpf_testmod_kfunc.h is included by both bpf_testmod and bpf programs that use test kfuncs. As suggested by David, the bpf_testmod_kfunc.h includes vmlinux.h and bpf/bpf_helpers.h for bpf programs build, so the declarations have proper __ksym attribute and we can resolve all the structs. Note in kfunc_call_test_subprog.c we can no longer use the sk_state define from bpf_tcp_helpers.h (because it clashed with vmlinux.h) and we need to address __sk_common.skc_state field directly. Acked-by: David Vernet <void@manifault.com> Signed-off-by: Jiri Olsa <jolsa@kernel.org> Link: https://lore.kernel.org/r/20230515133756.1658301-3-jolsa@kernel.org Signed-off-by: Alexei Starovoitov <ast@kernel.org>
153 lines
3 KiB
C
153 lines
3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright (c) 2021 Facebook */
|
|
#include <vmlinux.h>
|
|
#include <bpf/bpf_helpers.h>
|
|
#include "../bpf_testmod/bpf_testmod_kfunc.h"
|
|
|
|
struct syscall_test_args {
|
|
__u8 data[16];
|
|
size_t size;
|
|
};
|
|
|
|
SEC("?syscall")
|
|
int kfunc_syscall_test_fail(struct syscall_test_args *args)
|
|
{
|
|
bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(*args) + 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
SEC("?syscall")
|
|
int kfunc_syscall_test_null_fail(struct syscall_test_args *args)
|
|
{
|
|
/* Must be called with args as a NULL pointer
|
|
* we do not check for it to have the verifier consider that
|
|
* the pointer might not be null, and so we can load it.
|
|
*
|
|
* So the following can not be added:
|
|
*
|
|
* if (args)
|
|
* return -22;
|
|
*/
|
|
|
|
bpf_kfunc_call_test_mem_len_pass1(args, sizeof(*args));
|
|
|
|
return 0;
|
|
}
|
|
|
|
SEC("?tc")
|
|
int kfunc_call_test_get_mem_fail_rdonly(struct __sk_buff *skb)
|
|
{
|
|
struct prog_test_ref_kfunc *pt;
|
|
unsigned long s = 0;
|
|
int *p = NULL;
|
|
int ret = 0;
|
|
|
|
pt = bpf_kfunc_call_test_acquire(&s);
|
|
if (pt) {
|
|
p = bpf_kfunc_call_test_get_rdonly_mem(pt, 2 * sizeof(int));
|
|
if (p)
|
|
p[0] = 42; /* this is a read-only buffer, so -EACCES */
|
|
else
|
|
ret = -1;
|
|
|
|
bpf_kfunc_call_test_release(pt);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
SEC("?tc")
|
|
int kfunc_call_test_get_mem_fail_use_after_free(struct __sk_buff *skb)
|
|
{
|
|
struct prog_test_ref_kfunc *pt;
|
|
unsigned long s = 0;
|
|
int *p = NULL;
|
|
int ret = 0;
|
|
|
|
pt = bpf_kfunc_call_test_acquire(&s);
|
|
if (pt) {
|
|
p = bpf_kfunc_call_test_get_rdwr_mem(pt, 2 * sizeof(int));
|
|
if (p) {
|
|
p[0] = 42;
|
|
ret = p[1]; /* 108 */
|
|
} else {
|
|
ret = -1;
|
|
}
|
|
|
|
bpf_kfunc_call_test_release(pt);
|
|
}
|
|
if (p)
|
|
ret = p[0]; /* p is not valid anymore */
|
|
|
|
return ret;
|
|
}
|
|
|
|
SEC("?tc")
|
|
int kfunc_call_test_get_mem_fail_oob(struct __sk_buff *skb)
|
|
{
|
|
struct prog_test_ref_kfunc *pt;
|
|
unsigned long s = 0;
|
|
int *p = NULL;
|
|
int ret = 0;
|
|
|
|
pt = bpf_kfunc_call_test_acquire(&s);
|
|
if (pt) {
|
|
p = bpf_kfunc_call_test_get_rdonly_mem(pt, 2 * sizeof(int));
|
|
if (p)
|
|
ret = p[2 * sizeof(int)]; /* oob access, so -EACCES */
|
|
else
|
|
ret = -1;
|
|
|
|
bpf_kfunc_call_test_release(pt);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int not_const_size = 2 * sizeof(int);
|
|
|
|
SEC("?tc")
|
|
int kfunc_call_test_get_mem_fail_not_const(struct __sk_buff *skb)
|
|
{
|
|
struct prog_test_ref_kfunc *pt;
|
|
unsigned long s = 0;
|
|
int *p = NULL;
|
|
int ret = 0;
|
|
|
|
pt = bpf_kfunc_call_test_acquire(&s);
|
|
if (pt) {
|
|
p = bpf_kfunc_call_test_get_rdonly_mem(pt, not_const_size); /* non const size, -EINVAL */
|
|
if (p)
|
|
ret = p[0];
|
|
else
|
|
ret = -1;
|
|
|
|
bpf_kfunc_call_test_release(pt);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
SEC("?tc")
|
|
int kfunc_call_test_mem_acquire_fail(struct __sk_buff *skb)
|
|
{
|
|
struct prog_test_ref_kfunc *pt;
|
|
unsigned long s = 0;
|
|
int *p = NULL;
|
|
int ret = 0;
|
|
|
|
pt = bpf_kfunc_call_test_acquire(&s);
|
|
if (pt) {
|
|
/* we are failing on this one, because we are not acquiring a PTR_TO_BTF_ID (a struct ptr) */
|
|
p = bpf_kfunc_call_test_acq_rdonly_mem(pt, 2 * sizeof(int));
|
|
if (p)
|
|
ret = p[0];
|
|
else
|
|
ret = -1;
|
|
|
|
bpf_kfunc_call_int_mem_release(p);
|
|
|
|
bpf_kfunc_call_test_release(pt);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
char _license[] SEC("license") = "GPL";
|