Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2#define _GNU_SOURCE
3#include <test_progs.h>
4
5struct inst {
6 struct bpf_object *obj;
7 struct bpf_link *link;
8};
9
10static struct bpf_program *load_prog(char *file, char *name, struct inst *inst)
11{
12 struct bpf_object *obj;
13 struct bpf_program *prog;
14 int err;
15
16 obj = bpf_object__open_file(file, NULL);
17 if (!ASSERT_OK_PTR(obj, "obj_open_file"))
18 return NULL;
19
20 inst->obj = obj;
21
22 err = bpf_object__load(obj);
23 if (!ASSERT_OK(err, "obj_load"))
24 return NULL;
25
26 prog = bpf_object__find_program_by_name(obj, name);
27 if (!ASSERT_OK_PTR(prog, "obj_find_prog"))
28 return NULL;
29
30 return prog;
31}
32
33/* TODO: use different target function to run in concurrent mode */
34void serial_test_trampoline_count(void)
35{
36 char *file = "test_trampoline_count.bpf.o";
37 char *const progs[] = { "fentry_test", "fmod_ret_test", "fexit_test" };
38 int bpf_max_tramp_links, err, i, prog_fd;
39 struct bpf_program *prog;
40 struct bpf_link *link;
41 struct inst *inst;
42 LIBBPF_OPTS(bpf_test_run_opts, opts);
43
44 bpf_max_tramp_links = get_bpf_max_tramp_links();
45 if (!ASSERT_GE(bpf_max_tramp_links, 1, "bpf_max_tramp_links"))
46 return;
47 inst = calloc(bpf_max_tramp_links + 1, sizeof(*inst));
48 if (!ASSERT_OK_PTR(inst, "inst"))
49 return;
50
51 /* attach 'allowed' trampoline programs */
52 for (i = 0; i < bpf_max_tramp_links; i++) {
53 prog = load_prog(file, progs[i % ARRAY_SIZE(progs)], &inst[i]);
54 if (!prog)
55 goto cleanup;
56
57 link = bpf_program__attach(prog);
58 if (!ASSERT_OK_PTR(link, "attach_prog"))
59 goto cleanup;
60
61 inst[i].link = link;
62 }
63
64 /* and try 1 extra.. */
65 prog = load_prog(file, "fmod_ret_test", &inst[i]);
66 if (!prog)
67 goto cleanup;
68
69 /* ..that needs to fail */
70 link = bpf_program__attach(prog);
71 if (!ASSERT_ERR_PTR(link, "attach_prog")) {
72 inst[i].link = link;
73 goto cleanup;
74 }
75
76 /* with E2BIG error */
77 if (!ASSERT_EQ(libbpf_get_error(link), -E2BIG, "E2BIG"))
78 goto cleanup;
79 if (!ASSERT_EQ(link, NULL, "ptr_is_null"))
80 goto cleanup;
81
82 /* and finally execute the probe */
83 prog_fd = bpf_program__fd(prog);
84 if (!ASSERT_GE(prog_fd, 0, "bpf_program__fd"))
85 goto cleanup;
86
87 err = bpf_prog_test_run_opts(prog_fd, &opts);
88 if (!ASSERT_OK(err, "bpf_prog_test_run_opts"))
89 goto cleanup;
90
91 ASSERT_EQ(opts.retval & 0xffff, 33, "bpf_modify_return_test.result");
92 ASSERT_EQ(opts.retval >> 16, 2, "bpf_modify_return_test.side_effect");
93
94cleanup:
95 for (; i >= 0; i--) {
96 bpf_link__destroy(inst[i].link);
97 bpf_object__close(inst[i].obj);
98 }
99 free(inst);
100}
1// SPDX-License-Identifier: GPL-2.0-only
2#define _GNU_SOURCE
3#include <sched.h>
4#include <sys/prctl.h>
5#include <test_progs.h>
6
7#define MAX_TRAMP_PROGS 40
8
9struct inst {
10 struct bpf_object *obj;
11 struct bpf_link *link_fentry;
12 struct bpf_link *link_fexit;
13};
14
15static int test_task_rename(void)
16{
17 int fd, duration = 0, err;
18 char buf[] = "test_overhead";
19
20 fd = open("/proc/self/comm", O_WRONLY|O_TRUNC);
21 if (CHECK(fd < 0, "open /proc", "err %d", errno))
22 return -1;
23 err = write(fd, buf, sizeof(buf));
24 if (err < 0) {
25 CHECK(err < 0, "task rename", "err %d", errno);
26 close(fd);
27 return -1;
28 }
29 close(fd);
30 return 0;
31}
32
33static struct bpf_link *load(struct bpf_object *obj, const char *name)
34{
35 struct bpf_program *prog;
36 int duration = 0;
37
38 prog = bpf_object__find_program_by_title(obj, name);
39 if (CHECK(!prog, "find_probe", "prog '%s' not found\n", name))
40 return ERR_PTR(-EINVAL);
41 return bpf_program__attach_trace(prog);
42}
43
44void test_trampoline_count(void)
45{
46 const char *fentry_name = "fentry/__set_task_comm";
47 const char *fexit_name = "fexit/__set_task_comm";
48 const char *object = "test_trampoline_count.o";
49 struct inst inst[MAX_TRAMP_PROGS] = {};
50 int err, i = 0, duration = 0;
51 struct bpf_object *obj;
52 struct bpf_link *link;
53 char comm[16] = {};
54
55 /* attach 'allowed' 40 trampoline programs */
56 for (i = 0; i < MAX_TRAMP_PROGS; i++) {
57 obj = bpf_object__open_file(object, NULL);
58 if (CHECK(IS_ERR(obj), "obj_open_file", "err %ld\n", PTR_ERR(obj))) {
59 obj = NULL;
60 goto cleanup;
61 }
62
63 err = bpf_object__load(obj);
64 if (CHECK(err, "obj_load", "err %d\n", err))
65 goto cleanup;
66 inst[i].obj = obj;
67 obj = NULL;
68
69 if (rand() % 2) {
70 link = load(inst[i].obj, fentry_name);
71 if (CHECK(IS_ERR(link), "attach prog", "err %ld\n", PTR_ERR(link))) {
72 link = NULL;
73 goto cleanup;
74 }
75 inst[i].link_fentry = link;
76 } else {
77 link = load(inst[i].obj, fexit_name);
78 if (CHECK(IS_ERR(link), "attach prog", "err %ld\n", PTR_ERR(link))) {
79 link = NULL;
80 goto cleanup;
81 }
82 inst[i].link_fexit = link;
83 }
84 }
85
86 /* and try 1 extra.. */
87 obj = bpf_object__open_file(object, NULL);
88 if (CHECK(IS_ERR(obj), "obj_open_file", "err %ld\n", PTR_ERR(obj))) {
89 obj = NULL;
90 goto cleanup;
91 }
92
93 err = bpf_object__load(obj);
94 if (CHECK(err, "obj_load", "err %d\n", err))
95 goto cleanup_extra;
96
97 /* ..that needs to fail */
98 link = load(obj, fentry_name);
99 if (CHECK(!IS_ERR(link), "cannot attach over the limit", "err %ld\n", PTR_ERR(link))) {
100 bpf_link__destroy(link);
101 goto cleanup_extra;
102 }
103
104 /* with E2BIG error */
105 CHECK(PTR_ERR(link) != -E2BIG, "proper error check", "err %ld\n", PTR_ERR(link));
106
107 /* and finaly execute the probe */
108 if (CHECK_FAIL(prctl(PR_GET_NAME, comm, 0L, 0L, 0L)))
109 goto cleanup_extra;
110 CHECK_FAIL(test_task_rename());
111 CHECK_FAIL(prctl(PR_SET_NAME, comm, 0L, 0L, 0L));
112
113cleanup_extra:
114 bpf_object__close(obj);
115cleanup:
116 if (i >= MAX_TRAMP_PROGS)
117 i = MAX_TRAMP_PROGS - 1;
118 for (; i >= 0; i--) {
119 bpf_link__destroy(inst[i].link_fentry);
120 bpf_link__destroy(inst[i].link_fexit);
121 bpf_object__close(inst[i].obj);
122 }
123}