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 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 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 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 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 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 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 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 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