bpf/prog_tests/fexit_bpf2bpf.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2019 Facebook */
0003 #include <test_progs.h>
0004 #include <network_helpers.h>
0005 #include <bpf/btf.h>
0006 #include "bind4_prog.skel.h"
0007
0008 typedef int (*test_cb)(struct bpf_object *obj);
0009
0010 static int check_data_map(struct bpf_object *obj, int prog_cnt, bool reset)
0011 {
0012     struct bpf_map *data_map = NULL, *map;
0013     __u64 *result = NULL;
0014     const int zero = 0;
0015     __u32 duration = 0;
0016     int ret = -1, i;
0017
0018     result = malloc((prog_cnt + 32 /* spare */) * sizeof(__u64));
0019     if (CHECK(!result, "alloc_memory", "failed to alloc memory"))
0020         return -ENOMEM;
0021
0022     bpf_object__for_each_map(map, obj)
0023         if (bpf_map__is_internal(map)) {
0024             data_map = map;
0025             break;
0026         }
0027     if (CHECK(!data_map, "find_data_map", "data map not found\n"))
0028         goto out;
0029
0030     ret = bpf_map_lookup_elem(bpf_map__fd(data_map), &zero, result);
0031     if (CHECK(ret, "get_result",
0032           "failed to get output data: %d\n", ret))
0033         goto out;
0034
0035     for (i = 0; i < prog_cnt; i++) {
0036         if (CHECK(result[i] != 1, "result",
0037               "fexit_bpf2bpf result[%d] failed err %llu\n",
0038               i, result[i]))
0039             goto out;
0040         result[i] = 0;
0041     }
0042     if (reset) {
0043         ret = bpf_map_update_elem(bpf_map__fd(data_map), &zero, result, 0);
0044         if (CHECK(ret, "reset_result", "failed to reset result\n"))
0045             goto out;
0046     }
0047
0048     ret = 0;
0049 out:
0050     free(result);
0051     return ret;
0052 }
0053
0054 static void test_fexit_bpf2bpf_common(const char *obj_file,
0055                       const char *target_obj_file,
0056                       int prog_cnt,
0057                       const char **prog_name,
0058                       bool run_prog,
0059                       test_cb cb)
0060 {
0061     struct bpf_object *obj = NULL, *tgt_obj;
0062     __u32 tgt_prog_id, info_len;
0063     struct bpf_prog_info prog_info = {};
0064     struct bpf_program **prog = NULL, *p;
0065     struct bpf_link **link = NULL;
0066     int err, tgt_fd, i;
0067     struct btf *btf;
0068     LIBBPF_OPTS(bpf_test_run_opts, topts,
0069         .data_in = &pkt_v6,
0070         .data_size_in = sizeof(pkt_v6),
0071         .repeat = 1,
0072     );
0073
0074     err = bpf_prog_test_load(target_obj_file, BPF_PROG_TYPE_UNSPEC,
0075                 &tgt_obj, &tgt_fd);
0076     if (!ASSERT_OK(err, "tgt_prog_load"))
0077         return;
0078
0079     info_len = sizeof(prog_info);
0080     err = bpf_obj_get_info_by_fd(tgt_fd, &prog_info, &info_len);
0081     if (!ASSERT_OK(err, "tgt_fd_get_info"))
0082         goto close_prog;
0083
0084     tgt_prog_id = prog_info.id;
0085     btf = bpf_object__btf(tgt_obj);
0086
0087     link = calloc(sizeof(struct bpf_link *), prog_cnt);
0088     if (!ASSERT_OK_PTR(link, "link_ptr"))
0089         goto close_prog;
0090
0091     prog = calloc(sizeof(struct bpf_program *), prog_cnt);
0092     if (!ASSERT_OK_PTR(prog, "prog_ptr"))
0093         goto close_prog;
0094
0095     obj = bpf_object__open_file(obj_file, NULL);
0096     if (!ASSERT_OK_PTR(obj, "obj_open"))
0097         goto close_prog;
0098
0099     bpf_object__for_each_program(p, obj) {
0100         err = bpf_program__set_attach_target(p, tgt_fd, NULL);
0101         ASSERT_OK(err, "set_attach_target");
0102     }
0103
0104     err = bpf_object__load(obj);
0105     if (!ASSERT_OK(err, "obj_load"))
0106         goto close_prog;
0107
0108     for (i = 0; i < prog_cnt; i++) {
0109         struct bpf_link_info link_info;
0110         struct bpf_program *pos;
0111         const char *pos_sec_name;
0112         char *tgt_name;
0113         __s32 btf_id;
0114
0115         tgt_name = strstr(prog_name[i], "/");
0116         if (!ASSERT_OK_PTR(tgt_name, "tgt_name"))
0117             goto close_prog;
0118         btf_id = btf__find_by_name_kind(btf, tgt_name + 1, BTF_KIND_FUNC);
0119
0120         prog[i] = NULL;
0121         bpf_object__for_each_program(pos, obj) {
0122             pos_sec_name = bpf_program__section_name(pos);
0123             if (pos_sec_name && !strcmp(pos_sec_name, prog_name[i])) {
0124                 prog[i] = pos;
0125                 break;
0126             }
0127         }
0128         if (!ASSERT_OK_PTR(prog[i], prog_name[i]))
0129             goto close_prog;
0130
0131         link[i] = bpf_program__attach_trace(prog[i]);
0132         if (!ASSERT_OK_PTR(link[i], "attach_trace"))
0133             goto close_prog;
0134
0135         info_len = sizeof(link_info);
0136         memset(&link_info, 0, sizeof(link_info));
0137         err = bpf_obj_get_info_by_fd(bpf_link__fd(link[i]),
0138                          &link_info, &info_len);
0139         ASSERT_OK(err, "link_fd_get_info");
0140         ASSERT_EQ(link_info.tracing.attach_type,
0141               bpf_program__expected_attach_type(prog[i]),
0142               "link_attach_type");
0143         ASSERT_EQ(link_info.tracing.target_obj_id, tgt_prog_id, "link_tgt_obj_id");
0144         ASSERT_EQ(link_info.tracing.target_btf_id, btf_id, "link_tgt_btf_id");
0145     }
0146
0147     if (cb) {
0148         err = cb(obj);
0149         if (err)
0150             goto close_prog;
0151     }
0152
0153     if (!run_prog)
0154         goto close_prog;
0155
0156     err = bpf_prog_test_run_opts(tgt_fd, &topts);
0157     ASSERT_OK(err, "prog_run");
0158     ASSERT_EQ(topts.retval, 0, "prog_run_ret");
0159
0160     if (check_data_map(obj, prog_cnt, false))
0161         goto close_prog;
0162
0163 close_prog:
0164     for (i = 0; i < prog_cnt; i++)
0165         bpf_link__destroy(link[i]);
0166     bpf_object__close(obj);
0167     bpf_object__close(tgt_obj);
0168     free(link);
0169     free(prog);
0170 }
0171
0172 static void test_target_no_callees(void)
0173 {
0174     const char *prog_name[] = {
0175         "fexit/test_pkt_md_access",
0176     };
0177     test_fexit_bpf2bpf_common("./fexit_bpf2bpf_simple.o",
0178                   "./test_pkt_md_access.o",
0179                   ARRAY_SIZE(prog_name),
0180                   prog_name, true, NULL);
0181 }
0182
0183 static void test_target_yes_callees(void)
0184 {
0185     const char *prog_name[] = {
0186         "fexit/test_pkt_access",
0187         "fexit/test_pkt_access_subprog1",
0188         "fexit/test_pkt_access_subprog2",
0189         "fexit/test_pkt_access_subprog3",
0190     };
0191     test_fexit_bpf2bpf_common("./fexit_bpf2bpf.o",
0192                   "./test_pkt_access.o",
0193                   ARRAY_SIZE(prog_name),
0194                   prog_name, true, NULL);
0195 }
0196
0197 static void test_func_replace(void)
0198 {
0199     const char *prog_name[] = {
0200         "fexit/test_pkt_access",
0201         "fexit/test_pkt_access_subprog1",
0202         "fexit/test_pkt_access_subprog2",
0203         "fexit/test_pkt_access_subprog3",
0204         "freplace/get_skb_len",
0205         "freplace/get_skb_ifindex",
0206         "freplace/get_constant",
0207         "freplace/test_pkt_write_access_subprog",
0208     };
0209     test_fexit_bpf2bpf_common("./fexit_bpf2bpf.o",
0210                   "./test_pkt_access.o",
0211                   ARRAY_SIZE(prog_name),
0212                   prog_name, true, NULL);
0213 }
0214
0215 static void test_func_replace_verify(void)
0216 {
0217     const char *prog_name[] = {
0218         "freplace/do_bind",
0219     };
0220     test_fexit_bpf2bpf_common("./freplace_connect4.o",
0221                   "./connect4_prog.o",
0222                   ARRAY_SIZE(prog_name),
0223                   prog_name, false, NULL);
0224 }
0225
0226 static int test_second_attach(struct bpf_object *obj)
0227 {
0228     const char *prog_name = "security_new_get_constant";
0229     const char *tgt_name = "get_constant";
0230     const char *tgt_obj_file = "./test_pkt_access.o";
0231     struct bpf_program *prog = NULL;
0232     struct bpf_object *tgt_obj;
0233     struct bpf_link *link;
0234     int err = 0, tgt_fd;
0235     LIBBPF_OPTS(bpf_test_run_opts, topts,
0236         .data_in = &pkt_v6,
0237         .data_size_in = sizeof(pkt_v6),
0238         .repeat = 1,
0239     );
0240
0241     prog = bpf_object__find_program_by_name(obj, prog_name);
0242     if (!ASSERT_OK_PTR(prog, "find_prog"))
0243         return -ENOENT;
0244
0245     err = bpf_prog_test_load(tgt_obj_file, BPF_PROG_TYPE_UNSPEC,
0246                 &tgt_obj, &tgt_fd);
0247     if (!ASSERT_OK(err, "second_prog_load"))
0248         return err;
0249
0250     link = bpf_program__attach_freplace(prog, tgt_fd, tgt_name);
0251     if (!ASSERT_OK_PTR(link, "second_link"))
0252         goto out;
0253
0254     err = bpf_prog_test_run_opts(tgt_fd, &topts);
0255     if (!ASSERT_OK(err, "ipv6 test_run"))
0256         goto out;
0257     if (!ASSERT_OK(topts.retval, "ipv6 retval"))
0258         goto out;
0259
0260     err = check_data_map(obj, 1, true);
0261     if (err)
0262         goto out;
0263
0264 out:
0265     bpf_link__destroy(link);
0266     bpf_object__close(tgt_obj);
0267     return err;
0268 }
0269
0270 static void test_func_replace_multi(void)
0271 {
0272     const char *prog_name[] = {
0273         "freplace/get_constant",
0274     };
0275     test_fexit_bpf2bpf_common("./freplace_get_constant.o",
0276                   "./test_pkt_access.o",
0277                   ARRAY_SIZE(prog_name),
0278                   prog_name, true, test_second_attach);
0279 }
0280
0281 static void test_fmod_ret_freplace(void)
0282 {
0283     struct bpf_object *freplace_obj = NULL, *pkt_obj, *fmod_obj = NULL;
0284     const char *freplace_name = "./freplace_get_constant.o";
0285     const char *fmod_ret_name = "./fmod_ret_freplace.o";
0286     DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
0287     const char *tgt_name = "./test_pkt_access.o";
0288     struct bpf_link *freplace_link = NULL;
0289     struct bpf_program *prog;
0290     __u32 duration = 0;
0291     int err, pkt_fd, attach_prog_fd;
0292
0293     err = bpf_prog_test_load(tgt_name, BPF_PROG_TYPE_UNSPEC,
0294                 &pkt_obj, &pkt_fd);
0295     /* the target prog should load fine */
0296     if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",
0297           tgt_name, err, errno))
0298         return;
0299
0300     freplace_obj = bpf_object__open_file(freplace_name, NULL);
0301     if (!ASSERT_OK_PTR(freplace_obj, "freplace_obj_open"))
0302         goto out;
0303
0304     prog = bpf_object__next_program(freplace_obj, NULL);
0305     err = bpf_program__set_attach_target(prog, pkt_fd, NULL);
0306     ASSERT_OK(err, "freplace__set_attach_target");
0307
0308     err = bpf_object__load(freplace_obj);
0309     if (CHECK(err, "freplace_obj_load", "err %d\n", err))
0310         goto out;
0311
0312     freplace_link = bpf_program__attach_trace(prog);
0313     if (!ASSERT_OK_PTR(freplace_link, "freplace_attach_trace"))
0314         goto out;
0315
0316     fmod_obj = bpf_object__open_file(fmod_ret_name, NULL);
0317     if (!ASSERT_OK_PTR(fmod_obj, "fmod_obj_open"))
0318         goto out;
0319
0320     attach_prog_fd = bpf_program__fd(prog);
0321     prog = bpf_object__next_program(fmod_obj, NULL);
0322     err = bpf_program__set_attach_target(prog, attach_prog_fd, NULL);
0323     ASSERT_OK(err, "fmod_ret_set_attach_target");
0324
0325     err = bpf_object__load(fmod_obj);
0326     if (CHECK(!err, "fmod_obj_load", "loading fmod_ret should fail\n"))
0327         goto out;
0328
0329 out:
0330     bpf_link__destroy(freplace_link);
0331     bpf_object__close(freplace_obj);
0332     bpf_object__close(fmod_obj);
0333     bpf_object__close(pkt_obj);
0334 }
0335
0336
0337 static void test_func_sockmap_update(void)
0338 {
0339     const char *prog_name[] = {
0340         "freplace/cls_redirect",
0341     };
0342     test_fexit_bpf2bpf_common("./freplace_cls_redirect.o",
0343                   "./test_cls_redirect.o",
0344                   ARRAY_SIZE(prog_name),
0345                   prog_name, false, NULL);
0346 }
0347
0348 static void test_obj_load_failure_common(const char *obj_file,
0349                      const char *target_obj_file)
0350 {
0351     /*
0352      * standalone test that asserts failure to load freplace prog
0353      * because of invalid return code.
0354      */
0355     struct bpf_object *obj = NULL, *pkt_obj;
0356     struct bpf_program *prog;
0357     int err, pkt_fd;
0358     __u32 duration = 0;
0359
0360     err = bpf_prog_test_load(target_obj_file, BPF_PROG_TYPE_UNSPEC,
0361                 &pkt_obj, &pkt_fd);
0362     /* the target prog should load fine */
0363     if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",
0364           target_obj_file, err, errno))
0365         return;
0366
0367     obj = bpf_object__open_file(obj_file, NULL);
0368     if (!ASSERT_OK_PTR(obj, "obj_open"))
0369         goto close_prog;
0370
0371     prog = bpf_object__next_program(obj, NULL);
0372     err = bpf_program__set_attach_target(prog, pkt_fd, NULL);
0373     ASSERT_OK(err, "set_attach_target");
0374
0375     /* It should fail to load the program */
0376     err = bpf_object__load(obj);
0377     if (CHECK(!err, "bpf_obj_load should fail", "err %d\n", err))
0378         goto close_prog;
0379
0380 close_prog:
0381     bpf_object__close(obj);
0382     bpf_object__close(pkt_obj);
0383 }
0384
0385 static void test_func_replace_return_code(void)
0386 {
0387     /* test invalid return code in the replaced program */
0388     test_obj_load_failure_common("./freplace_connect_v4_prog.o",
0389                      "./connect4_prog.o");
0390 }
0391
0392 static void test_func_map_prog_compatibility(void)
0393 {
0394     /* test with spin lock map value in the replaced program */
0395     test_obj_load_failure_common("./freplace_attach_probe.o",
0396                      "./test_attach_probe.o");
0397 }
0398
0399 static void test_func_replace_global_func(void)
0400 {
0401     const char *prog_name[] = {
0402         "freplace/test_pkt_access",
0403     };
0404
0405     test_fexit_bpf2bpf_common("./freplace_global_func.o",
0406                   "./test_pkt_access.o",
0407                   ARRAY_SIZE(prog_name),
0408                   prog_name, false, NULL);
0409 }
0410
0411 static int find_prog_btf_id(const char *name, __u32 attach_prog_fd)
0412 {
0413     struct bpf_prog_info info = {};
0414     __u32 info_len = sizeof(info);
0415     struct btf *btf;
0416     int ret;
0417
0418     ret = bpf_obj_get_info_by_fd(attach_prog_fd, &info, &info_len);
0419     if (ret)
0420         return ret;
0421
0422     if (!info.btf_id)
0423         return -EINVAL;
0424
0425     btf = btf__load_from_kernel_by_id(info.btf_id);
0426     ret = libbpf_get_error(btf);
0427     if (ret)
0428         return ret;
0429
0430     ret = btf__find_by_name_kind(btf, name, BTF_KIND_FUNC);
0431     btf__free(btf);
0432     return ret;
0433 }
0434
0435 static int load_fentry(int attach_prog_fd, int attach_btf_id)
0436 {
0437     LIBBPF_OPTS(bpf_prog_load_opts, opts,
0438             .expected_attach_type = BPF_TRACE_FENTRY,
0439             .attach_prog_fd = attach_prog_fd,
0440             .attach_btf_id = attach_btf_id,
0441     );
0442     struct bpf_insn insns[] = {
0443         BPF_MOV64_IMM(BPF_REG_0, 0),
0444         BPF_EXIT_INSN(),
0445     };
0446
0447     return bpf_prog_load(BPF_PROG_TYPE_TRACING,
0448                  "bind4_fentry",
0449                  "GPL",
0450                  insns,
0451                  ARRAY_SIZE(insns),
0452                  &opts);
0453 }
0454
0455 static void test_fentry_to_cgroup_bpf(void)
0456 {
0457     struct bind4_prog *skel = NULL;
0458     struct bpf_prog_info info = {};
0459     __u32 info_len = sizeof(info);
0460     int cgroup_fd = -1;
0461     int fentry_fd = -1;
0462     int btf_id;
0463
0464     cgroup_fd = test__join_cgroup("/fentry_to_cgroup_bpf");
0465     if (!ASSERT_GE(cgroup_fd, 0, "cgroup_fd"))
0466         return;
0467
0468     skel = bind4_prog__open_and_load();
0469     if (!ASSERT_OK_PTR(skel, "skel"))
0470         goto cleanup;
0471
0472     skel->links.bind_v4_prog = bpf_program__attach_cgroup(skel->progs.bind_v4_prog, cgroup_fd);
0473     if (!ASSERT_OK_PTR(skel->links.bind_v4_prog, "bpf_program__attach_cgroup"))
0474         goto cleanup;
0475
0476     btf_id = find_prog_btf_id("bind_v4_prog", bpf_program__fd(skel->progs.bind_v4_prog));
0477     if (!ASSERT_GE(btf_id, 0, "find_prog_btf_id"))
0478         goto cleanup;
0479
0480     fentry_fd = load_fentry(bpf_program__fd(skel->progs.bind_v4_prog), btf_id);
0481     if (!ASSERT_GE(fentry_fd, 0, "load_fentry"))
0482         goto cleanup;
0483
0484     /* Make sure bpf_obj_get_info_by_fd works correctly when attaching
0485      * to another BPF program.
0486      */
0487
0488     ASSERT_OK(bpf_obj_get_info_by_fd(fentry_fd, &info, &info_len),
0489           "bpf_obj_get_info_by_fd");
0490
0491     ASSERT_EQ(info.btf_id, 0, "info.btf_id");
0492     ASSERT_EQ(info.attach_btf_id, btf_id, "info.attach_btf_id");
0493     ASSERT_GT(info.attach_btf_obj_id, 0, "info.attach_btf_obj_id");
0494
0495 cleanup:
0496     if (cgroup_fd >= 0)
0497         close(cgroup_fd);
0498     if (fentry_fd >= 0)
0499         close(fentry_fd);
0500     bind4_prog__destroy(skel);
0501 }
0502
0503 /* NOTE: affect other tests, must run in serial mode */
0504 void serial_test_fexit_bpf2bpf(void)
0505 {
0506     if (test__start_subtest("target_no_callees"))
0507         test_target_no_callees();
0508     if (test__start_subtest("target_yes_callees"))
0509         test_target_yes_callees();
0510     if (test__start_subtest("func_replace"))
0511         test_func_replace();
0512     if (test__start_subtest("func_replace_verify"))
0513         test_func_replace_verify();
0514     if (test__start_subtest("func_sockmap_update"))
0515         test_func_sockmap_update();
0516     if (test__start_subtest("func_replace_return_code"))
0517         test_func_replace_return_code();
0518     if (test__start_subtest("func_map_prog_compatibility"))
0519         test_func_map_prog_compatibility();
0520     if (test__start_subtest("func_replace_multi"))
0521         test_func_replace_multi();
0522     if (test__start_subtest("fmod_ret_freplace"))
0523         test_fmod_ret_freplace();
0524     if (test__start_subtest("func_replace_global_func"))
0525         test_func_replace_global_func();
0526     if (test__start_subtest("fentry_to_cgroup_bpf"))
0527         test_fentry_to_cgroup_bpf();
0528 }