forked from TencentOS/TencentOS-kernel
selftests/bpf: sync fentry/fexit test from upstream
Signed-off-by: Menglong Dong <imagedong@tencent.com>
This commit is contained in:
Menglong Dong
parent
427c0f52f1
commit
54e8a2943a
|
|
@ -1299,6 +1299,9 @@ int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,
|
|||
union bpf_attr __user *uattr);
|
||||
int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,
|
||||
union bpf_attr __user *uattr);
|
||||
int bpf_prog_test_run_tracing(struct bpf_prog *prog,
|
||||
const union bpf_attr *kattr,
|
||||
union bpf_attr __user *uattr);
|
||||
int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,
|
||||
const union bpf_attr *kattr,
|
||||
union bpf_attr __user *uattr);
|
||||
|
|
@ -1448,6 +1451,13 @@ static inline int bpf_prog_test_run_skb(struct bpf_prog *prog,
|
|||
return -ENOTSUPP;
|
||||
}
|
||||
|
||||
static inline int bpf_prog_test_run_tracing(struct bpf_prog *prog,
|
||||
const union bpf_attr *kattr,
|
||||
union bpf_attr __user *uattr)
|
||||
{
|
||||
return -ENOTSUPP;
|
||||
}
|
||||
|
||||
static inline int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,
|
||||
const union bpf_attr *kattr,
|
||||
union bpf_attr __user *uattr)
|
||||
|
|
|
|||
|
|
@ -1468,6 +1468,7 @@ const struct bpf_verifier_ops tracing_verifier_ops = {
|
|||
};
|
||||
|
||||
const struct bpf_prog_ops tracing_prog_ops = {
|
||||
.test_run = bpf_prog_test_run_tracing,
|
||||
};
|
||||
|
||||
static bool raw_tp_writable_prog_is_valid_access(int off, int size,
|
||||
|
|
|
|||
|
|
@ -160,16 +160,37 @@ static void *bpf_test_init(const union bpf_attr *kattr, u32 size,
|
|||
kfree(data);
|
||||
return ERR_PTR(-EFAULT);
|
||||
}
|
||||
if (bpf_fentry_test1(1) != 2 ||
|
||||
bpf_fentry_test2(2, 3) != 5 ||
|
||||
bpf_fentry_test3(4, 5, 6) != 15 ||
|
||||
bpf_fentry_test4((void *)7, 8, 9, 10) != 34 ||
|
||||
bpf_fentry_test5(11, (void *)12, 13, 14, 15) != 65 ||
|
||||
bpf_fentry_test6(16, (void *)17, 18, 19, (void *)20, 21) != 111)
|
||||
return ERR_PTR(-EFAULT);
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
int bpf_prog_test_run_tracing(struct bpf_prog *prog,
|
||||
const union bpf_attr *kattr,
|
||||
union bpf_attr __user *uattr)
|
||||
{
|
||||
int err = -EFAULT;
|
||||
|
||||
switch (prog->expected_attach_type) {
|
||||
case BPF_TRACE_FENTRY:
|
||||
case BPF_TRACE_FEXIT:
|
||||
if (bpf_fentry_test1(1) != 2 ||
|
||||
bpf_fentry_test2(2, 3) != 5 ||
|
||||
bpf_fentry_test3(4, 5, 6) != 15 ||
|
||||
bpf_fentry_test4((void *)7, 8, 9, 10) != 34 ||
|
||||
bpf_fentry_test5(11, (void *)12, 13, 14, 15) != 65 ||
|
||||
bpf_fentry_test6(16, (void *)17, 18, 19, (void *)20, 21) != 111)
|
||||
goto out;
|
||||
break;
|
||||
default:
|
||||
goto out;
|
||||
}
|
||||
|
||||
err = 0;
|
||||
out:
|
||||
trace_bpf_test_finish(&err);
|
||||
return err;
|
||||
}
|
||||
|
||||
static void *bpf_ctx_init(const union bpf_attr *kattr, u32 max_size)
|
||||
{
|
||||
void __user *data_in = u64_to_user_ptr(kattr->test.ctx_in);
|
||||
|
|
|
|||
|
|
@ -1,90 +1,49 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2019 Facebook */
|
||||
#include <test_progs.h>
|
||||
#include "fentry_test.skel.h"
|
||||
#include "fexit_test.skel.h"
|
||||
|
||||
void test_fentry_fexit(void)
|
||||
{
|
||||
struct bpf_prog_load_attr attr_fentry = {
|
||||
.file = "./fentry_test.o",
|
||||
};
|
||||
struct bpf_prog_load_attr attr_fexit = {
|
||||
.file = "./fexit_test.o",
|
||||
};
|
||||
struct fentry_test *fentry_skel = NULL;
|
||||
struct fexit_test *fexit_skel = NULL;
|
||||
__u64 *fentry_res, *fexit_res;
|
||||
__u32 duration = 0, retval;
|
||||
int err, prog_fd, i;
|
||||
|
||||
struct bpf_object *obj_fentry = NULL, *obj_fexit = NULL, *pkt_obj;
|
||||
struct bpf_map *data_map_fentry, *data_map_fexit;
|
||||
char fentry_name[] = "fentry/bpf_fentry_testX";
|
||||
char fexit_name[] = "fexit/bpf_fentry_testX";
|
||||
int err, pkt_fd, kfree_skb_fd, i;
|
||||
struct bpf_link *link[12] = {};
|
||||
struct bpf_program *prog[12];
|
||||
__u32 duration, retval;
|
||||
const int zero = 0;
|
||||
u64 result[12];
|
||||
|
||||
err = bpf_prog_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,
|
||||
&pkt_obj, &pkt_fd);
|
||||
if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno))
|
||||
return;
|
||||
err = bpf_prog_load_xattr(&attr_fentry, &obj_fentry, &kfree_skb_fd);
|
||||
if (CHECK(err, "prog_load fail", "err %d errno %d\n", err, errno))
|
||||
fentry_skel = fentry_test__open_and_load();
|
||||
if (CHECK(!fentry_skel, "fentry_skel_load", "fentry skeleton failed\n"))
|
||||
goto close_prog;
|
||||
err = bpf_prog_load_xattr(&attr_fexit, &obj_fexit, &kfree_skb_fd);
|
||||
if (CHECK(err, "prog_load fail", "err %d errno %d\n", err, errno))
|
||||
fexit_skel = fexit_test__open_and_load();
|
||||
if (CHECK(!fexit_skel, "fexit_skel_load", "fexit skeleton failed\n"))
|
||||
goto close_prog;
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
fentry_name[sizeof(fentry_name) - 2] = '1' + i;
|
||||
prog[i] = bpf_object__find_program_by_title(obj_fentry, fentry_name);
|
||||
if (CHECK(!prog[i], "find_prog", "prog %s not found\n", fentry_name))
|
||||
goto close_prog;
|
||||
link[i] = bpf_program__attach_trace(prog[i]);
|
||||
if (CHECK(IS_ERR(link[i]), "attach_trace", "failed to link\n"))
|
||||
goto close_prog;
|
||||
}
|
||||
data_map_fentry = bpf_object__find_map_by_name(obj_fentry, "fentry_t.bss");
|
||||
if (CHECK(!data_map_fentry, "find_data_map", "data map not found\n"))
|
||||
err = fentry_test__attach(fentry_skel);
|
||||
if (CHECK(err, "fentry_attach", "fentry attach failed: %d\n", err))
|
||||
goto close_prog;
|
||||
err = fexit_test__attach(fexit_skel);
|
||||
if (CHECK(err, "fexit_attach", "fexit attach failed: %d\n", err))
|
||||
goto close_prog;
|
||||
|
||||
for (i = 6; i < 12; i++) {
|
||||
fexit_name[sizeof(fexit_name) - 2] = '1' + i - 6;
|
||||
prog[i] = bpf_object__find_program_by_title(obj_fexit, fexit_name);
|
||||
if (CHECK(!prog[i], "find_prog", "prog %s not found\n", fexit_name))
|
||||
goto close_prog;
|
||||
link[i] = bpf_program__attach_trace(prog[i]);
|
||||
if (CHECK(IS_ERR(link[i]), "attach_trace", "failed to link\n"))
|
||||
goto close_prog;
|
||||
}
|
||||
data_map_fexit = bpf_object__find_map_by_name(obj_fexit, "fexit_te.bss");
|
||||
if (CHECK(!data_map_fexit, "find_data_map", "data map not found\n"))
|
||||
goto close_prog;
|
||||
|
||||
err = bpf_prog_test_run(pkt_fd, 1, &pkt_v6, sizeof(pkt_v6),
|
||||
prog_fd = bpf_program__fd(fexit_skel->progs.test1);
|
||||
err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
|
||||
NULL, NULL, &retval, &duration);
|
||||
CHECK(err || retval, "ipv6",
|
||||
"err %d errno %d retval %d duration %d\n",
|
||||
err, errno, retval, duration);
|
||||
|
||||
err = bpf_map_lookup_elem(bpf_map__fd(data_map_fentry), &zero, &result);
|
||||
if (CHECK(err, "get_result",
|
||||
"failed to get output data: %d\n", err))
|
||||
goto close_prog;
|
||||
|
||||
err = bpf_map_lookup_elem(bpf_map__fd(data_map_fexit), &zero, result + 6);
|
||||
if (CHECK(err, "get_result",
|
||||
"failed to get output data: %d\n", err))
|
||||
goto close_prog;
|
||||
|
||||
for (i = 0; i < 12; i++)
|
||||
if (CHECK(result[i] != 1, "result", "bpf_fentry_test%d failed err %ld\n",
|
||||
i % 6 + 1, result[i]))
|
||||
goto close_prog;
|
||||
fentry_res = (__u64 *)fentry_skel->bss;
|
||||
fexit_res = (__u64 *)fexit_skel->bss;
|
||||
printf("%lld\n", fentry_skel->bss->test1_result);
|
||||
for (i = 0; i < 6; i++) {
|
||||
CHECK(fentry_res[i] != 1, "result",
|
||||
"fentry_test%d failed err %lld\n", i + 1, fentry_res[i]);
|
||||
CHECK(fexit_res[i] != 1, "result",
|
||||
"fexit_test%d failed err %lld\n", i + 1, fexit_res[i]);
|
||||
}
|
||||
|
||||
close_prog:
|
||||
for (i = 0; i < 12; i++)
|
||||
if (!IS_ERR_OR_NULL(link[i]))
|
||||
bpf_link__destroy(link[i]);
|
||||
bpf_object__close(obj_fentry);
|
||||
bpf_object__close(obj_fexit);
|
||||
bpf_object__close(pkt_obj);
|
||||
fentry_test__destroy(fentry_skel);
|
||||
fexit_test__destroy(fexit_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,64 +1,55 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2019 Facebook */
|
||||
#include <test_progs.h>
|
||||
#include "fentry_test.skel.h"
|
||||
|
||||
static int fentry_test(struct fentry_test *fentry_skel)
|
||||
{
|
||||
int err, prog_fd, i;
|
||||
__u32 duration = 0, retval;
|
||||
struct bpf_link *link;
|
||||
__u64 *result;
|
||||
|
||||
err = fentry_test__attach(fentry_skel);
|
||||
if (!ASSERT_OK(err, "fentry_attach"))
|
||||
return err;
|
||||
|
||||
/* Check that already linked program can't be attached again. */
|
||||
link = bpf_program__attach(fentry_skel->progs.test1);
|
||||
if (!ASSERT_ERR_PTR(link, "fentry_attach_link"))
|
||||
return -1;
|
||||
|
||||
prog_fd = bpf_program__fd(fentry_skel->progs.test1);
|
||||
err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
|
||||
NULL, NULL, &retval, &duration);
|
||||
ASSERT_OK(err, "test_run");
|
||||
ASSERT_EQ(retval, 0, "test_run");
|
||||
|
||||
result = (__u64 *)fentry_skel->bss;
|
||||
for (i = 0; i < sizeof(*fentry_skel->bss) / sizeof(__u64); i++) {
|
||||
if (!ASSERT_EQ(result[i], 1, "fentry_result"))
|
||||
return -1;
|
||||
}
|
||||
|
||||
fentry_test__detach(fentry_skel);
|
||||
|
||||
/* zero results for re-attach test */
|
||||
memset(fentry_skel->bss, 0, sizeof(*fentry_skel->bss));
|
||||
return 0;
|
||||
}
|
||||
|
||||
void test_fentry_test(void)
|
||||
{
|
||||
struct bpf_prog_load_attr attr = {
|
||||
.file = "./fentry_test.o",
|
||||
};
|
||||
struct fentry_test *fentry_skel = NULL;
|
||||
int err;
|
||||
|
||||
char prog_name[] = "fentry/bpf_fentry_testX";
|
||||
struct bpf_object *obj = NULL, *pkt_obj;
|
||||
int err, pkt_fd, kfree_skb_fd, i;
|
||||
struct bpf_link *link[6] = {};
|
||||
struct bpf_program *prog[6];
|
||||
__u32 duration, retval;
|
||||
struct bpf_map *data_map;
|
||||
const int zero = 0;
|
||||
u64 result[6];
|
||||
fentry_skel = fentry_test__open_and_load();
|
||||
if (!ASSERT_OK_PTR(fentry_skel, "fentry_skel_load"))
|
||||
goto cleanup;
|
||||
|
||||
err = bpf_prog_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,
|
||||
&pkt_obj, &pkt_fd);
|
||||
if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno))
|
||||
return;
|
||||
err = bpf_prog_load_xattr(&attr, &obj, &kfree_skb_fd);
|
||||
if (CHECK(err, "prog_load fail", "err %d errno %d\n", err, errno))
|
||||
goto close_prog;
|
||||
err = fentry_test(fentry_skel);
|
||||
ASSERT_OK(err, "fentry_first_attach");
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
prog_name[sizeof(prog_name) - 2] = '1' + i;
|
||||
prog[i] = bpf_object__find_program_by_title(obj, prog_name);
|
||||
if (CHECK(!prog[i], "find_prog", "prog %s not found\n", prog_name))
|
||||
goto close_prog;
|
||||
link[i] = bpf_program__attach_trace(prog[i]);
|
||||
if (CHECK(IS_ERR(link[i]), "attach_trace", "failed to link\n"))
|
||||
goto close_prog;
|
||||
}
|
||||
data_map = bpf_object__find_map_by_name(obj, "fentry_t.bss");
|
||||
if (CHECK(!data_map, "find_data_map", "data map not found\n"))
|
||||
goto close_prog;
|
||||
|
||||
err = bpf_prog_test_run(pkt_fd, 1, &pkt_v6, sizeof(pkt_v6),
|
||||
NULL, NULL, &retval, &duration);
|
||||
CHECK(err || retval, "ipv6",
|
||||
"err %d errno %d retval %d duration %d\n",
|
||||
err, errno, retval, duration);
|
||||
|
||||
err = bpf_map_lookup_elem(bpf_map__fd(data_map), &zero, &result);
|
||||
if (CHECK(err, "get_result",
|
||||
"failed to get output data: %d\n", err))
|
||||
goto close_prog;
|
||||
|
||||
for (i = 0; i < 6; i++)
|
||||
if (CHECK(result[i] != 1, "result", "bpf_fentry_test%d failed err %ld\n",
|
||||
i + 1, result[i]))
|
||||
goto close_prog;
|
||||
|
||||
close_prog:
|
||||
for (i = 0; i < 6; i++)
|
||||
if (!IS_ERR_OR_NULL(link[i]))
|
||||
bpf_link__destroy(link[i]);
|
||||
bpf_object__close(obj);
|
||||
bpf_object__close(pkt_obj);
|
||||
cleanup:
|
||||
fentry_test__destroy(fentry_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,64 +1,55 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2019 Facebook */
|
||||
#include <test_progs.h>
|
||||
#include "fexit_test.skel.h"
|
||||
|
||||
static int fexit_test(struct fexit_test *fexit_skel)
|
||||
{
|
||||
int err, prog_fd, i;
|
||||
__u32 duration = 0, retval;
|
||||
struct bpf_link *link;
|
||||
__u64 *result;
|
||||
|
||||
err = fexit_test__attach(fexit_skel);
|
||||
if (!ASSERT_OK(err, "fexit_attach"))
|
||||
return err;
|
||||
|
||||
/* Check that already linked program can't be attached again. */
|
||||
link = bpf_program__attach(fexit_skel->progs.test1);
|
||||
if (!ASSERT_ERR_PTR(link, "fexit_attach_link"))
|
||||
return -1;
|
||||
|
||||
prog_fd = bpf_program__fd(fexit_skel->progs.test1);
|
||||
err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
|
||||
NULL, NULL, &retval, &duration);
|
||||
ASSERT_OK(err, "test_run");
|
||||
ASSERT_EQ(retval, 0, "test_run");
|
||||
|
||||
result = (__u64 *)fexit_skel->bss;
|
||||
for (i = 0; i < sizeof(*fexit_skel->bss) / sizeof(__u64); i++) {
|
||||
if (!ASSERT_EQ(result[i], 1, "fexit_result"))
|
||||
return -1;
|
||||
}
|
||||
|
||||
fexit_test__detach(fexit_skel);
|
||||
|
||||
/* zero results for re-attach test */
|
||||
memset(fexit_skel->bss, 0, sizeof(*fexit_skel->bss));
|
||||
return 0;
|
||||
}
|
||||
|
||||
void test_fexit_test(void)
|
||||
{
|
||||
struct bpf_prog_load_attr attr = {
|
||||
.file = "./fexit_test.o",
|
||||
};
|
||||
struct fexit_test *fexit_skel = NULL;
|
||||
int err;
|
||||
|
||||
char prog_name[] = "fexit/bpf_fentry_testX";
|
||||
struct bpf_object *obj = NULL, *pkt_obj;
|
||||
int err, pkt_fd, kfree_skb_fd, i;
|
||||
struct bpf_link *link[6] = {};
|
||||
struct bpf_program *prog[6];
|
||||
__u32 duration, retval;
|
||||
struct bpf_map *data_map;
|
||||
const int zero = 0;
|
||||
u64 result[6];
|
||||
fexit_skel = fexit_test__open_and_load();
|
||||
if (!ASSERT_OK_PTR(fexit_skel, "fexit_skel_load"))
|
||||
goto cleanup;
|
||||
|
||||
err = bpf_prog_load("./test_pkt_access.o", BPF_PROG_TYPE_SCHED_CLS,
|
||||
&pkt_obj, &pkt_fd);
|
||||
if (CHECK(err, "prog_load sched cls", "err %d errno %d\n", err, errno))
|
||||
return;
|
||||
err = bpf_prog_load_xattr(&attr, &obj, &kfree_skb_fd);
|
||||
if (CHECK(err, "prog_load fail", "err %d errno %d\n", err, errno))
|
||||
goto close_prog;
|
||||
err = fexit_test(fexit_skel);
|
||||
ASSERT_OK(err, "fexit_first_attach");
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
prog_name[sizeof(prog_name) - 2] = '1' + i;
|
||||
prog[i] = bpf_object__find_program_by_title(obj, prog_name);
|
||||
if (CHECK(!prog[i], "find_prog", "prog %s not found\n", prog_name))
|
||||
goto close_prog;
|
||||
link[i] = bpf_program__attach_trace(prog[i]);
|
||||
if (CHECK(IS_ERR(link[i]), "attach_trace", "failed to link\n"))
|
||||
goto close_prog;
|
||||
}
|
||||
data_map = bpf_object__find_map_by_name(obj, "fexit_te.bss");
|
||||
if (CHECK(!data_map, "find_data_map", "data map not found\n"))
|
||||
goto close_prog;
|
||||
|
||||
err = bpf_prog_test_run(pkt_fd, 1, &pkt_v6, sizeof(pkt_v6),
|
||||
NULL, NULL, &retval, &duration);
|
||||
CHECK(err || retval, "ipv6",
|
||||
"err %d errno %d retval %d duration %d\n",
|
||||
err, errno, retval, duration);
|
||||
|
||||
err = bpf_map_lookup_elem(bpf_map__fd(data_map), &zero, &result);
|
||||
if (CHECK(err, "get_result",
|
||||
"failed to get output data: %d\n", err))
|
||||
goto close_prog;
|
||||
|
||||
for (i = 0; i < 6; i++)
|
||||
if (CHECK(result[i] != 1, "result", "bpf_fentry_test%d failed err %ld\n",
|
||||
i + 1, result[i]))
|
||||
goto close_prog;
|
||||
|
||||
close_prog:
|
||||
for (i = 0; i < 6; i++)
|
||||
if (!IS_ERR_OR_NULL(link[i]))
|
||||
bpf_link__destroy(link[i]);
|
||||
bpf_object__close(obj);
|
||||
bpf_object__close(pkt_obj);
|
||||
cleanup:
|
||||
fexit_test__destroy(fexit_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,90 +1,57 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2019 Facebook */
|
||||
#include <linux/bpf.h>
|
||||
#include "bpf_helpers.h"
|
||||
#include <bpf/bpf_helpers.h>
|
||||
#include <bpf/bpf_tracing.h>
|
||||
|
||||
char _license[] SEC("license") = "GPL";
|
||||
|
||||
struct test1 {
|
||||
ks32 a;
|
||||
};
|
||||
static volatile __u64 test1_result;
|
||||
__u64 test1_result = 0;
|
||||
SEC("fentry/bpf_fentry_test1")
|
||||
int test1(struct test1 *ctx)
|
||||
int BPF_PROG(test1, int a)
|
||||
{
|
||||
test1_result = ctx->a == 1;
|
||||
test1_result = a == 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct test2 {
|
||||
ks32 a;
|
||||
ku64 b;
|
||||
};
|
||||
static volatile __u64 test2_result;
|
||||
__u64 test2_result = 0;
|
||||
SEC("fentry/bpf_fentry_test2")
|
||||
int test2(struct test2 *ctx)
|
||||
int BPF_PROG(test2, int a, __u64 b)
|
||||
{
|
||||
test2_result = ctx->a == 2 && ctx->b == 3;
|
||||
test2_result = a == 2 && b == 3;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct test3 {
|
||||
ks8 a;
|
||||
ks32 b;
|
||||
ku64 c;
|
||||
};
|
||||
static volatile __u64 test3_result;
|
||||
__u64 test3_result = 0;
|
||||
SEC("fentry/bpf_fentry_test3")
|
||||
int test3(struct test3 *ctx)
|
||||
int BPF_PROG(test3, char a, int b, __u64 c)
|
||||
{
|
||||
test3_result = ctx->a == 4 && ctx->b == 5 && ctx->c == 6;
|
||||
test3_result = a == 4 && b == 5 && c == 6;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct test4 {
|
||||
void *a;
|
||||
ks8 b;
|
||||
ks32 c;
|
||||
ku64 d;
|
||||
};
|
||||
static volatile __u64 test4_result;
|
||||
__u64 test4_result = 0;
|
||||
SEC("fentry/bpf_fentry_test4")
|
||||
int test4(struct test4 *ctx)
|
||||
int BPF_PROG(test4, void *a, char b, int c, __u64 d)
|
||||
{
|
||||
test4_result = ctx->a == (void *)7 && ctx->b == 8 && ctx->c == 9 &&
|
||||
ctx->d == 10;
|
||||
test4_result = a == (void *)7 && b == 8 && c == 9 && d == 10;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct test5 {
|
||||
ku64 a;
|
||||
void *b;
|
||||
ks16 c;
|
||||
ks32 d;
|
||||
ku64 e;
|
||||
};
|
||||
static volatile __u64 test5_result;
|
||||
__u64 test5_result = 0;
|
||||
SEC("fentry/bpf_fentry_test5")
|
||||
int test5(struct test5 *ctx)
|
||||
int BPF_PROG(test5, __u64 a, void *b, short c, int d, __u64 e)
|
||||
{
|
||||
test5_result = ctx->a == 11 && ctx->b == (void *)12 && ctx->c == 13 &&
|
||||
ctx->d == 14 && ctx->e == 15;
|
||||
test5_result = a == 11 && b == (void *)12 && c == 13 && d == 14 &&
|
||||
e == 15;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct test6 {
|
||||
ku64 a;
|
||||
void *b;
|
||||
ks16 c;
|
||||
ks32 d;
|
||||
void *e;
|
||||
ks64 f;
|
||||
};
|
||||
static volatile __u64 test6_result;
|
||||
__u64 test6_result = 0;
|
||||
SEC("fentry/bpf_fentry_test6")
|
||||
int test6(struct test6 *ctx)
|
||||
int BPF_PROG(test6, __u64 a, void *b, short c, int d, void * e, __u64 f)
|
||||
{
|
||||
test6_result = ctx->a == 16 && ctx->b == (void *)17 && ctx->c == 18 &&
|
||||
ctx->d == 19 && ctx->e == (void *)20 && ctx->f == 21;
|
||||
test6_result = a == 16 && b == (void *)17 && c == 18 && d == 19 &&
|
||||
e == (void *)20 && f == 21;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -119,6 +119,152 @@ extern struct ipv6_packet pkt_v6;
|
|||
#define CHECK_ATTR(condition, tag, format...) \
|
||||
_CHECK(condition, tag, tattr.duration, format)
|
||||
|
||||
#define ASSERT_TRUE(actual, name) ({ \
|
||||
static int duration = 0; \
|
||||
bool ___ok = (actual); \
|
||||
CHECK(!___ok, (name), "unexpected %s: got FALSE\n", (name)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_FALSE(actual, name) ({ \
|
||||
static int duration = 0; \
|
||||
bool ___ok = !(actual); \
|
||||
CHECK(!___ok, (name), "unexpected %s: got TRUE\n", (name)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_EQ(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
typeof(actual) ___act = (actual); \
|
||||
typeof(expected) ___exp = (expected); \
|
||||
bool ___ok = ___act == ___exp; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual %lld != expected %lld\n", \
|
||||
(name), (long long)(___act), (long long)(___exp)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_NEQ(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
typeof(actual) ___act = (actual); \
|
||||
typeof(expected) ___exp = (expected); \
|
||||
bool ___ok = ___act != ___exp; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual %lld == expected %lld\n", \
|
||||
(name), (long long)(___act), (long long)(___exp)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_LT(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
typeof(actual) ___act = (actual); \
|
||||
typeof(expected) ___exp = (expected); \
|
||||
bool ___ok = ___act < ___exp; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual %lld >= expected %lld\n", \
|
||||
(name), (long long)(___act), (long long)(___exp)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_LE(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
typeof(actual) ___act = (actual); \
|
||||
typeof(expected) ___exp = (expected); \
|
||||
bool ___ok = ___act <= ___exp; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual %lld > expected %lld\n", \
|
||||
(name), (long long)(___act), (long long)(___exp)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_GT(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
typeof(actual) ___act = (actual); \
|
||||
typeof(expected) ___exp = (expected); \
|
||||
bool ___ok = ___act > ___exp; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual %lld <= expected %lld\n", \
|
||||
(name), (long long)(___act), (long long)(___exp)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_GE(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
typeof(actual) ___act = (actual); \
|
||||
typeof(expected) ___exp = (expected); \
|
||||
bool ___ok = ___act >= ___exp; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual %lld < expected %lld\n", \
|
||||
(name), (long long)(___act), (long long)(___exp)); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_STREQ(actual, expected, name) ({ \
|
||||
static int duration = 0; \
|
||||
const char *___act = actual; \
|
||||
const char *___exp = expected; \
|
||||
bool ___ok = strcmp(___act, ___exp) == 0; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual '%s' != expected '%s'\n", \
|
||||
(name), ___act, ___exp); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_STRNEQ(actual, expected, len, name) ({ \
|
||||
static int duration = 0; \
|
||||
const char *___act = actual; \
|
||||
const char *___exp = expected; \
|
||||
int ___len = len; \
|
||||
bool ___ok = strncmp(___act, ___exp, ___len) == 0; \
|
||||
CHECK(!___ok, (name), \
|
||||
"unexpected %s: actual '%.*s' != expected '%.*s'\n", \
|
||||
(name), ___len, ___act, ___len, ___exp); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_OK(res, name) ({ \
|
||||
static int duration = 0; \
|
||||
long long ___res = (res); \
|
||||
bool ___ok = ___res == 0; \
|
||||
CHECK(!___ok, (name), "unexpected error: %lld (errno %d)\n", \
|
||||
___res, errno); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_ERR(res, name) ({ \
|
||||
static int duration = 0; \
|
||||
long long ___res = (res); \
|
||||
bool ___ok = ___res < 0; \
|
||||
CHECK(!___ok, (name), "unexpected success: %lld\n", ___res); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_NULL(ptr, name) ({ \
|
||||
static int duration = 0; \
|
||||
const void *___res = (ptr); \
|
||||
bool ___ok = !___res; \
|
||||
CHECK(!___ok, (name), "unexpected pointer: %p\n", ___res); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_OK_PTR(ptr, name) ({ \
|
||||
static int duration = 0; \
|
||||
const void *___res = (ptr); \
|
||||
int ___err = libbpf_get_error(___res); \
|
||||
bool ___ok = ___err == 0; \
|
||||
CHECK(!___ok, (name), "unexpected error: %d\n", ___err); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define ASSERT_ERR_PTR(ptr, name) ({ \
|
||||
static int duration = 0; \
|
||||
const void *___res = (ptr); \
|
||||
int ___err = libbpf_get_error(___res); \
|
||||
bool ___ok = ___err != 0; \
|
||||
CHECK(!___ok, (name), "unexpected pointer: %p\n", ___res); \
|
||||
___ok; \
|
||||
})
|
||||
|
||||
#define MAGIC_VAL 0x1234
|
||||
#define NUM_ITER 100000
|
||||
#define VIP_NUM 5
|
||||
|
|
|
|||
Loading…
Reference in New Issue