bpf/prog_tests/sockmap_basic.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Copyright (c) 2020 Cloudflare
0003 #include <error.h>
0004 #include <netinet/tcp.h>
0005
0006 #include "test_progs.h"
0007 #include "test_skmsg_load_helpers.skel.h"
0008 #include "test_sockmap_update.skel.h"
0009 #include "test_sockmap_invalid_update.skel.h"
0010 #include "test_sockmap_skb_verdict_attach.skel.h"
0011 #include "test_sockmap_progs_query.skel.h"
0012 #include "bpf_iter_sockmap.skel.h"
0013
0014 #define TCP_REPAIR      19  /* TCP sock is under repair right now */
0015
0016 #define TCP_REPAIR_ON       1
0017 #define TCP_REPAIR_OFF_NO_WP    -1  /* Turn off without window probes */
0018
0019 static int connected_socket_v4(void)
0020 {
0021     struct sockaddr_in addr = {
0022         .sin_family = AF_INET,
0023         .sin_port = htons(80),
0024         .sin_addr = { inet_addr("127.0.0.1") },
0025     };
0026     socklen_t len = sizeof(addr);
0027     int s, repair, err;
0028
0029     s = socket(AF_INET, SOCK_STREAM, 0);
0030     if (CHECK_FAIL(s == -1))
0031         goto error;
0032
0033     repair = TCP_REPAIR_ON;
0034     err = setsockopt(s, SOL_TCP, TCP_REPAIR, &repair, sizeof(repair));
0035     if (CHECK_FAIL(err))
0036         goto error;
0037
0038     err = connect(s, (struct sockaddr *)&addr, len);
0039     if (CHECK_FAIL(err))
0040         goto error;
0041
0042     repair = TCP_REPAIR_OFF_NO_WP;
0043     err = setsockopt(s, SOL_TCP, TCP_REPAIR, &repair, sizeof(repair));
0044     if (CHECK_FAIL(err))
0045         goto error;
0046
0047     return s;
0048 error:
0049     perror(__func__);
0050     close(s);
0051     return -1;
0052 }
0053
0054 static void compare_cookies(struct bpf_map *src, struct bpf_map *dst)
0055 {
0056     __u32 i, max_entries = bpf_map__max_entries(src);
0057     int err, duration = 0, src_fd, dst_fd;
0058
0059     src_fd = bpf_map__fd(src);
0060     dst_fd = bpf_map__fd(dst);
0061
0062     for (i = 0; i < max_entries; i++) {
0063         __u64 src_cookie, dst_cookie;
0064
0065         err = bpf_map_lookup_elem(src_fd, &i, &src_cookie);
0066         if (err && errno == ENOENT) {
0067             err = bpf_map_lookup_elem(dst_fd, &i, &dst_cookie);
0068             CHECK(!err, "map_lookup_elem(dst)", "element %u not deleted\n", i);
0069             CHECK(err && errno != ENOENT, "map_lookup_elem(dst)", "%s\n",
0070                   strerror(errno));
0071             continue;
0072         }
0073         if (CHECK(err, "lookup_elem(src)", "%s\n", strerror(errno)))
0074             continue;
0075
0076         err = bpf_map_lookup_elem(dst_fd, &i, &dst_cookie);
0077         if (CHECK(err, "lookup_elem(dst)", "%s\n", strerror(errno)))
0078             continue;
0079
0080         CHECK(dst_cookie != src_cookie, "cookie mismatch",
0081               "%llu != %llu (pos %u)\n", dst_cookie, src_cookie, i);
0082     }
0083 }
0084
0085 /* Create a map, populate it with one socket, and free the map. */
0086 static void test_sockmap_create_update_free(enum bpf_map_type map_type)
0087 {
0088     const int zero = 0;
0089     int s, map, err;
0090
0091     s = connected_socket_v4();
0092     if (CHECK_FAIL(s < 0))
0093         return;
0094
0095     map = bpf_map_create(map_type, NULL, sizeof(int), sizeof(int), 1, NULL);
0096     if (CHECK_FAIL(map < 0)) {
0097         perror("bpf_cmap_create");
0098         goto out;
0099     }
0100
0101     err = bpf_map_update_elem(map, &zero, &s, BPF_NOEXIST);
0102     if (CHECK_FAIL(err)) {
0103         perror("bpf_map_update");
0104         goto out;
0105     }
0106
0107 out:
0108     close(map);
0109     close(s);
0110 }
0111
0112 static void test_skmsg_helpers(enum bpf_map_type map_type)
0113 {
0114     struct test_skmsg_load_helpers *skel;
0115     int err, map, verdict;
0116
0117     skel = test_skmsg_load_helpers__open_and_load();
0118     if (CHECK_FAIL(!skel)) {
0119         perror("test_skmsg_load_helpers__open_and_load");
0120         return;
0121     }
0122
0123     verdict = bpf_program__fd(skel->progs.prog_msg_verdict);
0124     map = bpf_map__fd(skel->maps.sock_map);
0125
0126     err = bpf_prog_attach(verdict, map, BPF_SK_MSG_VERDICT, 0);
0127     if (CHECK_FAIL(err)) {
0128         perror("bpf_prog_attach");
0129         goto out;
0130     }
0131
0132     err = bpf_prog_detach2(verdict, map, BPF_SK_MSG_VERDICT);
0133     if (CHECK_FAIL(err)) {
0134         perror("bpf_prog_detach2");
0135         goto out;
0136     }
0137 out:
0138     test_skmsg_load_helpers__destroy(skel);
0139 }
0140
0141 static void test_sockmap_update(enum bpf_map_type map_type)
0142 {
0143     int err, prog, src, duration = 0;
0144     struct test_sockmap_update *skel;
0145     struct bpf_map *dst_map;
0146     const __u32 zero = 0;
0147     char dummy[14] = {0};
0148     LIBBPF_OPTS(bpf_test_run_opts, topts,
0149         .data_in = dummy,
0150         .data_size_in = sizeof(dummy),
0151         .repeat = 1,
0152     );
0153     __s64 sk;
0154
0155     sk = connected_socket_v4();
0156     if (CHECK(sk == -1, "connected_socket_v4", "cannot connect\n"))
0157         return;
0158
0159     skel = test_sockmap_update__open_and_load();
0160     if (CHECK(!skel, "open_and_load", "cannot load skeleton\n"))
0161         goto close_sk;
0162
0163     prog = bpf_program__fd(skel->progs.copy_sock_map);
0164     src = bpf_map__fd(skel->maps.src);
0165     if (map_type == BPF_MAP_TYPE_SOCKMAP)
0166         dst_map = skel->maps.dst_sock_map;
0167     else
0168         dst_map = skel->maps.dst_sock_hash;
0169
0170     err = bpf_map_update_elem(src, &zero, &sk, BPF_NOEXIST);
0171     if (CHECK(err, "update_elem(src)", "errno=%u\n", errno))
0172         goto out;
0173
0174     err = bpf_prog_test_run_opts(prog, &topts);
0175     if (!ASSERT_OK(err, "test_run"))
0176         goto out;
0177     if (!ASSERT_NEQ(topts.retval, 0, "test_run retval"))
0178         goto out;
0179
0180     compare_cookies(skel->maps.src, dst_map);
0181
0182 out:
0183     test_sockmap_update__destroy(skel);
0184 close_sk:
0185     close(sk);
0186 }
0187
0188 static void test_sockmap_invalid_update(void)
0189 {
0190     struct test_sockmap_invalid_update *skel;
0191     int duration = 0;
0192
0193     skel = test_sockmap_invalid_update__open_and_load();
0194     if (CHECK(skel, "open_and_load", "verifier accepted map_update\n"))
0195         test_sockmap_invalid_update__destroy(skel);
0196 }
0197
0198 static void test_sockmap_copy(enum bpf_map_type map_type)
0199 {
0200     DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
0201     int err, len, src_fd, iter_fd, duration = 0;
0202     union bpf_iter_link_info linfo = {};
0203     __u32 i, num_sockets, num_elems;
0204     struct bpf_iter_sockmap *skel;
0205     __s64 *sock_fd = NULL;
0206     struct bpf_link *link;
0207     struct bpf_map *src;
0208     char buf[64];
0209
0210     skel = bpf_iter_sockmap__open_and_load();
0211     if (CHECK(!skel, "bpf_iter_sockmap__open_and_load", "skeleton open_and_load failed\n"))
0212         return;
0213
0214     if (map_type == BPF_MAP_TYPE_SOCKMAP) {
0215         src = skel->maps.sockmap;
0216         num_elems = bpf_map__max_entries(src);
0217         num_sockets = num_elems - 1;
0218     } else {
0219         src = skel->maps.sockhash;
0220         num_elems = bpf_map__max_entries(src) - 1;
0221         num_sockets = num_elems;
0222     }
0223
0224     sock_fd = calloc(num_sockets, sizeof(*sock_fd));
0225     if (CHECK(!sock_fd, "calloc(sock_fd)", "failed to allocate\n"))
0226         goto out;
0227
0228     for (i = 0; i < num_sockets; i++)
0229         sock_fd[i] = -1;
0230
0231     src_fd = bpf_map__fd(src);
0232
0233     for (i = 0; i < num_sockets; i++) {
0234         sock_fd[i] = connected_socket_v4();
0235         if (CHECK(sock_fd[i] == -1, "connected_socket_v4", "cannot connect\n"))
0236             goto out;
0237
0238         err = bpf_map_update_elem(src_fd, &i, &sock_fd[i], BPF_NOEXIST);
0239         if (CHECK(err, "map_update", "failed: %s\n", strerror(errno)))
0240             goto out;
0241     }
0242
0243     linfo.map.map_fd = src_fd;
0244     opts.link_info = &linfo;
0245     opts.link_info_len = sizeof(linfo);
0246     link = bpf_program__attach_iter(skel->progs.copy, &opts);
0247     if (!ASSERT_OK_PTR(link, "attach_iter"))
0248         goto out;
0249
0250     iter_fd = bpf_iter_create(bpf_link__fd(link));
0251     if (CHECK(iter_fd < 0, "create_iter", "create_iter failed\n"))
0252         goto free_link;
0253
0254     /* do some tests */
0255     while ((len = read(iter_fd, buf, sizeof(buf))) > 0)
0256         ;
0257     if (CHECK(len < 0, "read", "failed: %s\n", strerror(errno)))
0258         goto close_iter;
0259
0260     /* test results */
0261     if (CHECK(skel->bss->elems != num_elems, "elems", "got %u expected %u\n",
0262           skel->bss->elems, num_elems))
0263         goto close_iter;
0264
0265     if (CHECK(skel->bss->socks != num_sockets, "socks", "got %u expected %u\n",
0266           skel->bss->socks, num_sockets))
0267         goto close_iter;
0268
0269     compare_cookies(src, skel->maps.dst);
0270
0271 close_iter:
0272     close(iter_fd);
0273 free_link:
0274     bpf_link__destroy(link);
0275 out:
0276     for (i = 0; sock_fd && i < num_sockets; i++)
0277         if (sock_fd[i] >= 0)
0278             close(sock_fd[i]);
0279     if (sock_fd)
0280         free(sock_fd);
0281     bpf_iter_sockmap__destroy(skel);
0282 }
0283
0284 static void test_sockmap_skb_verdict_attach(enum bpf_attach_type first,
0285                         enum bpf_attach_type second)
0286 {
0287     struct test_sockmap_skb_verdict_attach *skel;
0288     int err, map, verdict;
0289
0290     skel = test_sockmap_skb_verdict_attach__open_and_load();
0291     if (CHECK_FAIL(!skel)) {
0292         perror("test_sockmap_skb_verdict_attach__open_and_load");
0293         return;
0294     }
0295
0296     verdict = bpf_program__fd(skel->progs.prog_skb_verdict);
0297     map = bpf_map__fd(skel->maps.sock_map);
0298
0299     err = bpf_prog_attach(verdict, map, first, 0);
0300     if (CHECK_FAIL(err)) {
0301         perror("bpf_prog_attach");
0302         goto out;
0303     }
0304
0305     err = bpf_prog_attach(verdict, map, second, 0);
0306     ASSERT_EQ(err, -EBUSY, "prog_attach_fail");
0307
0308     err = bpf_prog_detach2(verdict, map, first);
0309     if (CHECK_FAIL(err)) {
0310         perror("bpf_prog_detach2");
0311         goto out;
0312     }
0313 out:
0314     test_sockmap_skb_verdict_attach__destroy(skel);
0315 }
0316
0317 static __u32 query_prog_id(int prog_fd)
0318 {
0319     struct bpf_prog_info info = {};
0320     __u32 info_len = sizeof(info);
0321     int err;
0322
0323     err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
0324     if (!ASSERT_OK(err, "bpf_obj_get_info_by_fd") ||
0325         !ASSERT_EQ(info_len, sizeof(info), "bpf_obj_get_info_by_fd"))
0326         return 0;
0327
0328     return info.id;
0329 }
0330
0331 static void test_sockmap_progs_query(enum bpf_attach_type attach_type)
0332 {
0333     struct test_sockmap_progs_query *skel;
0334     int err, map_fd, verdict_fd;
0335     __u32 attach_flags = 0;
0336     __u32 prog_ids[3] = {};
0337     __u32 prog_cnt = 3;
0338
0339     skel = test_sockmap_progs_query__open_and_load();
0340     if (!ASSERT_OK_PTR(skel, "test_sockmap_progs_query__open_and_load"))
0341         return;
0342
0343     map_fd = bpf_map__fd(skel->maps.sock_map);
0344
0345     if (attach_type == BPF_SK_MSG_VERDICT)
0346         verdict_fd = bpf_program__fd(skel->progs.prog_skmsg_verdict);
0347     else
0348         verdict_fd = bpf_program__fd(skel->progs.prog_skb_verdict);
0349
0350     err = bpf_prog_query(map_fd, attach_type, 0 /* query flags */,
0351                  &attach_flags, prog_ids, &prog_cnt);
0352     ASSERT_OK(err, "bpf_prog_query failed");
0353     ASSERT_EQ(attach_flags,  0, "wrong attach_flags on query");
0354     ASSERT_EQ(prog_cnt, 0, "wrong program count on query");
0355
0356     err = bpf_prog_attach(verdict_fd, map_fd, attach_type, 0);
0357     if (!ASSERT_OK(err, "bpf_prog_attach failed"))
0358         goto out;
0359
0360     prog_cnt = 1;
0361     err = bpf_prog_query(map_fd, attach_type, 0 /* query flags */,
0362                  &attach_flags, prog_ids, &prog_cnt);
0363     ASSERT_OK(err, "bpf_prog_query failed");
0364     ASSERT_EQ(attach_flags, 0, "wrong attach_flags on query");
0365     ASSERT_EQ(prog_cnt, 1, "wrong program count on query");
0366     ASSERT_EQ(prog_ids[0], query_prog_id(verdict_fd),
0367           "wrong prog_ids on query");
0368
0369     bpf_prog_detach2(verdict_fd, map_fd, attach_type);
0370 out:
0371     test_sockmap_progs_query__destroy(skel);
0372 }
0373
0374 void test_sockmap_basic(void)
0375 {
0376     if (test__start_subtest("sockmap create_update_free"))
0377         test_sockmap_create_update_free(BPF_MAP_TYPE_SOCKMAP);
0378     if (test__start_subtest("sockhash create_update_free"))
0379         test_sockmap_create_update_free(BPF_MAP_TYPE_SOCKHASH);
0380     if (test__start_subtest("sockmap sk_msg load helpers"))
0381         test_skmsg_helpers(BPF_MAP_TYPE_SOCKMAP);
0382     if (test__start_subtest("sockhash sk_msg load helpers"))
0383         test_skmsg_helpers(BPF_MAP_TYPE_SOCKHASH);
0384     if (test__start_subtest("sockmap update"))
0385         test_sockmap_update(BPF_MAP_TYPE_SOCKMAP);
0386     if (test__start_subtest("sockhash update"))
0387         test_sockmap_update(BPF_MAP_TYPE_SOCKHASH);
0388     if (test__start_subtest("sockmap update in unsafe context"))
0389         test_sockmap_invalid_update();
0390     if (test__start_subtest("sockmap copy"))
0391         test_sockmap_copy(BPF_MAP_TYPE_SOCKMAP);
0392     if (test__start_subtest("sockhash copy"))
0393         test_sockmap_copy(BPF_MAP_TYPE_SOCKHASH);
0394     if (test__start_subtest("sockmap skb_verdict attach")) {
0395         test_sockmap_skb_verdict_attach(BPF_SK_SKB_VERDICT,
0396                         BPF_SK_SKB_STREAM_VERDICT);
0397         test_sockmap_skb_verdict_attach(BPF_SK_SKB_STREAM_VERDICT,
0398                         BPF_SK_SKB_VERDICT);
0399     }
0400     if (test__start_subtest("sockmap msg_verdict progs query"))
0401         test_sockmap_progs_query(BPF_SK_MSG_VERDICT);
0402     if (test__start_subtest("sockmap stream_parser progs query"))
0403         test_sockmap_progs_query(BPF_SK_SKB_STREAM_PARSER);
0404     if (test__start_subtest("sockmap stream_verdict progs query"))
0405         test_sockmap_progs_query(BPF_SK_SKB_STREAM_VERDICT);
0406     if (test__start_subtest("sockmap skb_verdict progs query"))
0407         test_sockmap_progs_query(BPF_SK_SKB_VERDICT);
0408 }