1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2021 Facebook */
3 #include <test_progs.h>
4 #include <network_helpers.h>
5 #include "kfunc_call_fail.skel.h"
6 #include "kfunc_call_test.skel.h"
7 #include "kfunc_call_test.lskel.h"
8 #include "kfunc_call_test_subprog.skel.h"
9 #include "kfunc_call_test_subprog.lskel.h"
10 #include "kfunc_call_destructive.skel.h"
11
12 #include "cap_helpers.h"
13
14 static size_t log_buf_sz = 1048576; /* 1 MB */
15 static char obj_log_buf[1048576];
16
17 enum kfunc_test_type {
18 tc_test = 0,
19 syscall_test,
20 syscall_null_ctx_test,
21 };
22
23 struct kfunc_test_params {
24 const char *prog_name;
25 unsigned long lskel_prog_desc_offset;
26 int retval;
27 enum kfunc_test_type test_type;
28 const char *expected_err_msg;
29 };
30
31 #define __BPF_TEST_SUCCESS(name, __retval, type) \
32 { \
33 .prog_name = #name, \
34 .lskel_prog_desc_offset = offsetof(struct kfunc_call_test_lskel, progs.name), \
35 .retval = __retval, \
36 .test_type = type, \
37 .expected_err_msg = NULL, \
38 }
39
40 #define __BPF_TEST_FAIL(name, __retval, type, error_msg) \
41 { \
42 .prog_name = #name, \
43 .lskel_prog_desc_offset = 0 /* unused when test is failing */, \
44 .retval = __retval, \
45 .test_type = type, \
46 .expected_err_msg = error_msg, \
47 }
48
49 #define TC_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, tc_test)
50 #define SYSCALL_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, syscall_test)
51 #define SYSCALL_NULL_CTX_TEST(name, retval) __BPF_TEST_SUCCESS(name, retval, syscall_null_ctx_test)
52
53 #define TC_FAIL(name, retval, error_msg) __BPF_TEST_FAIL(name, retval, tc_test, error_msg)
54 #define SYSCALL_NULL_CTX_FAIL(name, retval, error_msg) \
55 __BPF_TEST_FAIL(name, retval, syscall_null_ctx_test, error_msg)
56
57 static struct kfunc_test_params kfunc_tests[] = {
58 /* failure cases:
59 * if retval is 0 -> the program will fail to load and the error message is an error
60 * if retval is not 0 -> the program can be loaded but running it will gives the
61 * provided return value. The error message is thus the one
62 * from a successful load
63 */
64 SYSCALL_NULL_CTX_FAIL(kfunc_syscall_test_fail, -EINVAL, "processed 4 insns"),
65 SYSCALL_NULL_CTX_FAIL(kfunc_syscall_test_null_fail, -EINVAL, "processed 4 insns"),
66 TC_FAIL(kfunc_call_test_get_mem_fail_rdonly, 0, "R0 cannot write into rdonly_mem"),
67 TC_FAIL(kfunc_call_test_get_mem_fail_use_after_free, 0, "invalid mem access 'scalar'"),
68 TC_FAIL(kfunc_call_test_get_mem_fail_oob, 0, "min value is outside of the allowed memory range"),
69 TC_FAIL(kfunc_call_test_get_mem_fail_zero_size, 0, "min value is outside of the allowed memory range"),
70 TC_FAIL(kfunc_call_test_get_mem_fail_oversized, 0, "allocation size exceeds u32 max"),
71 TC_FAIL(kfunc_call_test_get_mem_fail_not_const, 0, "is not a const"),
72 TC_FAIL(kfunc_call_test_mem_acquire_fail, 0, "acquire kernel function does not return PTR_TO_BTF_ID"),
73 TC_FAIL(kfunc_call_test_pointer_arg_type_mismatch, 0, "R1 expected pointer to ctx, but got scalar"),
74 TC_FAIL(kfunc_call_test_spin_lock_unsafe, 0, "function calls are not allowed while holding a lock"),
75
76 /* success cases */
77 TC_TEST(kfunc_call_test_spin_lock_safe, 0),
78 TC_TEST(kfunc_call_test1, 12),
79 TC_TEST(kfunc_call_test2, 3),
80 TC_TEST(kfunc_call_test4, -1234),
81 TC_TEST(kfunc_call_test5, 0),
82 TC_TEST(kfunc_call_test5_asm, 0),
83 TC_TEST(kfunc_call_test_ref_btf_id, 0),
84 TC_TEST(kfunc_call_test_get_mem, 42),
85 SYSCALL_TEST(kfunc_syscall_test, 0),
86 SYSCALL_NULL_CTX_TEST(kfunc_syscall_test_null, 0),
87 TC_TEST(kfunc_call_test_static_unused_arg, 0),
88 TC_TEST(kfunc_call_ctx, 0),
89 };
90
91 struct syscall_test_args {
92 __u8 data[16];
93 size_t size;
94 };
95
verify_success(struct kfunc_test_params * param)96 static void verify_success(struct kfunc_test_params *param)
97 {
98 struct kfunc_call_test_lskel *lskel = NULL;
99 LIBBPF_OPTS(bpf_test_run_opts, topts);
100 struct bpf_prog_desc *lskel_prog;
101 struct kfunc_call_test *skel;
102 struct bpf_program *prog;
103 int prog_fd, err;
104 struct syscall_test_args args = {
105 .size = 10,
106 };
107
108 switch (param->test_type) {
109 case syscall_test:
110 topts.ctx_in = &args;
111 topts.ctx_size_in = sizeof(args);
112 /* fallthrough */
113 case syscall_null_ctx_test:
114 break;
115 case tc_test:
116 topts.data_in = &pkt_v4;
117 topts.data_size_in = sizeof(pkt_v4);
118 topts.repeat = 1;
119 break;
120 }
121
122 /* first test with normal libbpf */
123 skel = kfunc_call_test__open_and_load();
124 if (!ASSERT_OK_PTR(skel, "skel"))
125 return;
126
127 prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);
128 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
129 goto cleanup;
130
131 prog_fd = bpf_program__fd(prog);
132 err = bpf_prog_test_run_opts(prog_fd, &topts);
133 if (!ASSERT_OK(err, param->prog_name))
134 goto cleanup;
135
136 if (!ASSERT_EQ(topts.retval, param->retval, "retval"))
137 goto cleanup;
138
139 /* second test with light skeletons */
140 lskel = kfunc_call_test_lskel__open_and_load();
141 if (!ASSERT_OK_PTR(lskel, "lskel"))
142 goto cleanup;
143
144 lskel_prog = (struct bpf_prog_desc *)((char *)lskel + param->lskel_prog_desc_offset);
145
146 prog_fd = lskel_prog->prog_fd;
147 err = bpf_prog_test_run_opts(prog_fd, &topts);
148 if (!ASSERT_OK(err, param->prog_name))
149 goto cleanup;
150
151 ASSERT_EQ(topts.retval, param->retval, "retval");
152
153 cleanup:
154 kfunc_call_test__destroy(skel);
155 if (lskel)
156 kfunc_call_test_lskel__destroy(lskel);
157 }
158
verify_fail(struct kfunc_test_params * param)159 static void verify_fail(struct kfunc_test_params *param)
160 {
161 LIBBPF_OPTS(bpf_object_open_opts, opts);
162 LIBBPF_OPTS(bpf_test_run_opts, topts);
163 struct bpf_program *prog;
164 struct kfunc_call_fail *skel;
165 int prog_fd, err;
166 struct syscall_test_args args = {
167 .size = 10,
168 };
169
170 opts.kernel_log_buf = obj_log_buf;
171 opts.kernel_log_size = log_buf_sz;
172 opts.kernel_log_level = 1;
173
174 switch (param->test_type) {
175 case syscall_test:
176 topts.ctx_in = &args;
177 topts.ctx_size_in = sizeof(args);
178 /* fallthrough */
179 case syscall_null_ctx_test:
180 break;
181 case tc_test:
182 topts.data_in = &pkt_v4;
183 topts.data_size_in = sizeof(pkt_v4);
184 topts.repeat = 1;
185 break;
186 }
187
188 skel = kfunc_call_fail__open_opts(&opts);
189 if (!ASSERT_OK_PTR(skel, "kfunc_call_fail__open_opts"))
190 goto cleanup;
191
192 prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);
193 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
194 goto cleanup;
195
196 bpf_program__set_autoload(prog, true);
197
198 err = kfunc_call_fail__load(skel);
199 if (!param->retval) {
200 /* the verifier is supposed to complain and refuses to load */
201 if (!ASSERT_ERR(err, "unexpected load success"))
202 goto out_err;
203
204 } else {
205 /* the program is loaded but must dynamically fail */
206 if (!ASSERT_OK(err, "unexpected load error"))
207 goto out_err;
208
209 prog_fd = bpf_program__fd(prog);
210 err = bpf_prog_test_run_opts(prog_fd, &topts);
211 if (!ASSERT_EQ(err, param->retval, param->prog_name))
212 goto out_err;
213 }
214
215 out_err:
216 if (!ASSERT_OK_PTR(strstr(obj_log_buf, param->expected_err_msg), "expected_err_msg")) {
217 fprintf(stderr, "Expected err_msg: %s\n", param->expected_err_msg);
218 fprintf(stderr, "Verifier output: %s\n", obj_log_buf);
219 }
220
221 cleanup:
222 kfunc_call_fail__destroy(skel);
223 }
224
test_main(void)225 static void test_main(void)
226 {
227 int i;
228
229 for (i = 0; i < ARRAY_SIZE(kfunc_tests); i++) {
230 if (!test__start_subtest(kfunc_tests[i].prog_name))
231 continue;
232
233 if (!kfunc_tests[i].expected_err_msg)
234 verify_success(&kfunc_tests[i]);
235 else
236 verify_fail(&kfunc_tests[i]);
237 }
238 }
239
test_subprog(void)240 static void test_subprog(void)
241 {
242 struct kfunc_call_test_subprog *skel;
243 int prog_fd, err;
244 LIBBPF_OPTS(bpf_test_run_opts, topts,
245 .data_in = &pkt_v4,
246 .data_size_in = sizeof(pkt_v4),
247 .repeat = 1,
248 );
249
250 skel = kfunc_call_test_subprog__open_and_load();
251 if (!ASSERT_OK_PTR(skel, "skel"))
252 return;
253
254 prog_fd = bpf_program__fd(skel->progs.kfunc_call_test1);
255 err = bpf_prog_test_run_opts(prog_fd, &topts);
256 ASSERT_OK(err, "bpf_prog_test_run(test1)");
257 ASSERT_EQ(topts.retval, 10, "test1-retval");
258 ASSERT_NEQ(skel->data->active_res, -1, "active_res");
259 ASSERT_EQ(skel->data->sk_state_res, BPF_TCP_CLOSE, "sk_state_res");
260
261 kfunc_call_test_subprog__destroy(skel);
262 }
263
test_subprog_lskel(void)264 static void test_subprog_lskel(void)
265 {
266 struct kfunc_call_test_subprog_lskel *skel;
267 int prog_fd, err;
268 LIBBPF_OPTS(bpf_test_run_opts, topts,
269 .data_in = &pkt_v4,
270 .data_size_in = sizeof(pkt_v4),
271 .repeat = 1,
272 );
273
274 skel = kfunc_call_test_subprog_lskel__open_and_load();
275 if (!ASSERT_OK_PTR(skel, "skel"))
276 return;
277
278 prog_fd = skel->progs.kfunc_call_test1.prog_fd;
279 err = bpf_prog_test_run_opts(prog_fd, &topts);
280 ASSERT_OK(err, "bpf_prog_test_run(test1)");
281 ASSERT_EQ(topts.retval, 10, "test1-retval");
282 ASSERT_NEQ(skel->data->active_res, -1, "active_res");
283 ASSERT_EQ(skel->data->sk_state_res, BPF_TCP_CLOSE, "sk_state_res");
284
285 kfunc_call_test_subprog_lskel__destroy(skel);
286 }
287
test_destructive_open_and_load(void)288 static int test_destructive_open_and_load(void)
289 {
290 struct kfunc_call_destructive *skel;
291 int err;
292
293 skel = kfunc_call_destructive__open();
294 if (!ASSERT_OK_PTR(skel, "prog_open"))
295 return -1;
296
297 err = kfunc_call_destructive__load(skel);
298
299 kfunc_call_destructive__destroy(skel);
300
301 return err;
302 }
303
test_destructive(void)304 static void test_destructive(void)
305 {
306 __u64 save_caps = 0;
307
308 ASSERT_OK(test_destructive_open_and_load(), "successful_load");
309
310 if (!ASSERT_OK(cap_disable_effective(1ULL << CAP_SYS_BOOT, &save_caps), "drop_caps"))
311 return;
312
313 ASSERT_EQ(test_destructive_open_and_load(), -13, "no_caps_failure");
314
315 cap_enable_effective(save_caps, NULL);
316 }
317
test_kfunc_call(void)318 void test_kfunc_call(void)
319 {
320 test_main();
321
322 if (test__start_subtest("subprog"))
323 test_subprog();
324
325 if (test__start_subtest("subprog_lskel"))
326 test_subprog_lskel();
327
328 if (test__start_subtest("destructive"))
329 test_destructive();
330 }
331