Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2018 Facebook */
0003 
0004 #include <stdlib.h>
0005 #include <unistd.h>
0006 #include <stdbool.h>
0007 #include <string.h>
0008 #include <errno.h>
0009 #include <assert.h>
0010 #include <fcntl.h>
0011 #include <linux/bpf.h>
0012 #include <linux/err.h>
0013 #include <linux/types.h>
0014 #include <linux/if_ether.h>
0015 #include <sys/types.h>
0016 #include <sys/epoll.h>
0017 #include <sys/socket.h>
0018 #include <netinet/in.h>
0019 #include <bpf/bpf.h>
0020 #include <bpf/libbpf.h>
0021 #include "bpf_util.h"
0022 
0023 #include "test_progs.h"
0024 #include "test_select_reuseport_common.h"
0025 
0026 #define MAX_TEST_NAME 80
0027 #define MIN_TCPHDR_LEN 20
0028 #define UDPHDR_LEN 8
0029 
0030 #define TCP_SYNCOOKIE_SYSCTL "/proc/sys/net/ipv4/tcp_syncookies"
0031 #define TCP_FO_SYSCTL "/proc/sys/net/ipv4/tcp_fastopen"
0032 #define REUSEPORT_ARRAY_SIZE 32
0033 
0034 static int result_map, tmp_index_ovr_map, linum_map, data_check_map;
0035 static __u32 expected_results[NR_RESULTS];
0036 static int sk_fds[REUSEPORT_ARRAY_SIZE];
0037 static int reuseport_array = -1, outer_map = -1;
0038 static enum bpf_map_type inner_map_type;
0039 static int select_by_skb_data_prog;
0040 static int saved_tcp_syncookie = -1;
0041 static struct bpf_object *obj;
0042 static int saved_tcp_fo = -1;
0043 static __u32 index_zero;
0044 static int epfd;
0045 
0046 static union sa46 {
0047     struct sockaddr_in6 v6;
0048     struct sockaddr_in v4;
0049     sa_family_t family;
0050 } srv_sa;
0051 
0052 #define RET_IF(condition, tag, format...) ({                \
0053     if (CHECK_FAIL(condition)) {                    \
0054         printf(tag " " format);                 \
0055         return;                         \
0056     }                               \
0057 })
0058 
0059 #define RET_ERR(condition, tag, format...) ({               \
0060     if (CHECK_FAIL(condition)) {                    \
0061         printf(tag " " format);                 \
0062         return -1;                      \
0063     }                               \
0064 })
0065 
0066 static int create_maps(enum bpf_map_type inner_type)
0067 {
0068     LIBBPF_OPTS(bpf_map_create_opts, opts);
0069 
0070     inner_map_type = inner_type;
0071 
0072     /* Creating reuseport_array */
0073     reuseport_array = bpf_map_create(inner_type, "reuseport_array",
0074                      sizeof(__u32), sizeof(__u32), REUSEPORT_ARRAY_SIZE, NULL);
0075     RET_ERR(reuseport_array < 0, "creating reuseport_array",
0076         "reuseport_array:%d errno:%d\n", reuseport_array, errno);
0077 
0078     /* Creating outer_map */
0079     opts.inner_map_fd = reuseport_array;
0080     outer_map = bpf_map_create(BPF_MAP_TYPE_ARRAY_OF_MAPS, "outer_map",
0081                    sizeof(__u32), sizeof(__u32), 1, &opts);
0082     RET_ERR(outer_map < 0, "creating outer_map",
0083         "outer_map:%d errno:%d\n", outer_map, errno);
0084 
0085     return 0;
0086 }
0087 
0088 static int prepare_bpf_obj(void)
0089 {
0090     struct bpf_program *prog;
0091     struct bpf_map *map;
0092     int err;
0093 
0094     obj = bpf_object__open("test_select_reuseport_kern.o");
0095     err = libbpf_get_error(obj);
0096     RET_ERR(err, "open test_select_reuseport_kern.o",
0097         "obj:%p PTR_ERR(obj):%d\n", obj, err);
0098 
0099     map = bpf_object__find_map_by_name(obj, "outer_map");
0100     RET_ERR(!map, "find outer_map", "!map\n");
0101     err = bpf_map__reuse_fd(map, outer_map);
0102     RET_ERR(err, "reuse outer_map", "err:%d\n", err);
0103 
0104     err = bpf_object__load(obj);
0105     RET_ERR(err, "load bpf_object", "err:%d\n", err);
0106 
0107     prog = bpf_object__next_program(obj, NULL);
0108     RET_ERR(!prog, "get first bpf_program", "!prog\n");
0109     select_by_skb_data_prog = bpf_program__fd(prog);
0110     RET_ERR(select_by_skb_data_prog < 0, "get prog fd",
0111         "select_by_skb_data_prog:%d\n", select_by_skb_data_prog);
0112 
0113     map = bpf_object__find_map_by_name(obj, "result_map");
0114     RET_ERR(!map, "find result_map", "!map\n");
0115     result_map = bpf_map__fd(map);
0116     RET_ERR(result_map < 0, "get result_map fd",
0117         "result_map:%d\n", result_map);
0118 
0119     map = bpf_object__find_map_by_name(obj, "tmp_index_ovr_map");
0120     RET_ERR(!map, "find tmp_index_ovr_map\n", "!map");
0121     tmp_index_ovr_map = bpf_map__fd(map);
0122     RET_ERR(tmp_index_ovr_map < 0, "get tmp_index_ovr_map fd",
0123         "tmp_index_ovr_map:%d\n", tmp_index_ovr_map);
0124 
0125     map = bpf_object__find_map_by_name(obj, "linum_map");
0126     RET_ERR(!map, "find linum_map", "!map\n");
0127     linum_map = bpf_map__fd(map);
0128     RET_ERR(linum_map < 0, "get linum_map fd",
0129         "linum_map:%d\n", linum_map);
0130 
0131     map = bpf_object__find_map_by_name(obj, "data_check_map");
0132     RET_ERR(!map, "find data_check_map", "!map\n");
0133     data_check_map = bpf_map__fd(map);
0134     RET_ERR(data_check_map < 0, "get data_check_map fd",
0135         "data_check_map:%d\n", data_check_map);
0136 
0137     return 0;
0138 }
0139 
0140 static void sa46_init_loopback(union sa46 *sa, sa_family_t family)
0141 {
0142     memset(sa, 0, sizeof(*sa));
0143     sa->family = family;
0144     if (sa->family == AF_INET6)
0145         sa->v6.sin6_addr = in6addr_loopback;
0146     else
0147         sa->v4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
0148 }
0149 
0150 static void sa46_init_inany(union sa46 *sa, sa_family_t family)
0151 {
0152     memset(sa, 0, sizeof(*sa));
0153     sa->family = family;
0154     if (sa->family == AF_INET6)
0155         sa->v6.sin6_addr = in6addr_any;
0156     else
0157         sa->v4.sin_addr.s_addr = INADDR_ANY;
0158 }
0159 
0160 static int read_int_sysctl(const char *sysctl)
0161 {
0162     char buf[16];
0163     int fd, ret;
0164 
0165     fd = open(sysctl, 0);
0166     RET_ERR(fd == -1, "open(sysctl)",
0167         "sysctl:%s fd:%d errno:%d\n", sysctl, fd, errno);
0168 
0169     ret = read(fd, buf, sizeof(buf));
0170     RET_ERR(ret <= 0, "read(sysctl)",
0171         "sysctl:%s ret:%d errno:%d\n", sysctl, ret, errno);
0172 
0173     close(fd);
0174     return atoi(buf);
0175 }
0176 
0177 static int write_int_sysctl(const char *sysctl, int v)
0178 {
0179     int fd, ret, size;
0180     char buf[16];
0181 
0182     fd = open(sysctl, O_RDWR);
0183     RET_ERR(fd == -1, "open(sysctl)",
0184         "sysctl:%s fd:%d errno:%d\n", sysctl, fd, errno);
0185 
0186     size = snprintf(buf, sizeof(buf), "%d", v);
0187     ret = write(fd, buf, size);
0188     RET_ERR(ret != size, "write(sysctl)",
0189         "sysctl:%s ret:%d size:%d errno:%d\n",
0190         sysctl, ret, size, errno);
0191 
0192     close(fd);
0193     return 0;
0194 }
0195 
0196 static void restore_sysctls(void)
0197 {
0198     if (saved_tcp_fo != -1)
0199         write_int_sysctl(TCP_FO_SYSCTL, saved_tcp_fo);
0200     if (saved_tcp_syncookie != -1)
0201         write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, saved_tcp_syncookie);
0202 }
0203 
0204 static int enable_fastopen(void)
0205 {
0206     int fo;
0207 
0208     fo = read_int_sysctl(TCP_FO_SYSCTL);
0209     if (fo < 0)
0210         return -1;
0211 
0212     return write_int_sysctl(TCP_FO_SYSCTL, fo | 7);
0213 }
0214 
0215 static int enable_syncookie(void)
0216 {
0217     return write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 2);
0218 }
0219 
0220 static int disable_syncookie(void)
0221 {
0222     return write_int_sysctl(TCP_SYNCOOKIE_SYSCTL, 0);
0223 }
0224 
0225 static long get_linum(void)
0226 {
0227     __u32 linum;
0228     int err;
0229 
0230     err = bpf_map_lookup_elem(linum_map, &index_zero, &linum);
0231     RET_ERR(err < 0, "lookup_elem(linum_map)", "err:%d errno:%d\n",
0232         err, errno);
0233 
0234     return linum;
0235 }
0236 
0237 static void check_data(int type, sa_family_t family, const struct cmd *cmd,
0238                int cli_fd)
0239 {
0240     struct data_check expected = {}, result;
0241     union sa46 cli_sa;
0242     socklen_t addrlen;
0243     int err;
0244 
0245     addrlen = sizeof(cli_sa);
0246     err = getsockname(cli_fd, (struct sockaddr *)&cli_sa,
0247               &addrlen);
0248     RET_IF(err < 0, "getsockname(cli_fd)", "err:%d errno:%d\n",
0249            err, errno);
0250 
0251     err = bpf_map_lookup_elem(data_check_map, &index_zero, &result);
0252     RET_IF(err < 0, "lookup_elem(data_check_map)", "err:%d errno:%d\n",
0253            err, errno);
0254 
0255     if (type == SOCK_STREAM) {
0256         expected.len = MIN_TCPHDR_LEN;
0257         expected.ip_protocol = IPPROTO_TCP;
0258     } else {
0259         expected.len = UDPHDR_LEN;
0260         expected.ip_protocol = IPPROTO_UDP;
0261     }
0262 
0263     if (family == AF_INET6) {
0264         expected.eth_protocol = htons(ETH_P_IPV6);
0265         expected.bind_inany = !srv_sa.v6.sin6_addr.s6_addr32[3] &&
0266             !srv_sa.v6.sin6_addr.s6_addr32[2] &&
0267             !srv_sa.v6.sin6_addr.s6_addr32[1] &&
0268             !srv_sa.v6.sin6_addr.s6_addr32[0];
0269 
0270         memcpy(&expected.skb_addrs[0], cli_sa.v6.sin6_addr.s6_addr32,
0271                sizeof(cli_sa.v6.sin6_addr));
0272         memcpy(&expected.skb_addrs[4], &in6addr_loopback,
0273                sizeof(in6addr_loopback));
0274         expected.skb_ports[0] = cli_sa.v6.sin6_port;
0275         expected.skb_ports[1] = srv_sa.v6.sin6_port;
0276     } else {
0277         expected.eth_protocol = htons(ETH_P_IP);
0278         expected.bind_inany = !srv_sa.v4.sin_addr.s_addr;
0279 
0280         expected.skb_addrs[0] = cli_sa.v4.sin_addr.s_addr;
0281         expected.skb_addrs[1] = htonl(INADDR_LOOPBACK);
0282         expected.skb_ports[0] = cli_sa.v4.sin_port;
0283         expected.skb_ports[1] = srv_sa.v4.sin_port;
0284     }
0285 
0286     if (memcmp(&result, &expected, offsetof(struct data_check,
0287                         equal_check_end))) {
0288         printf("unexpected data_check\n");
0289         printf("  result: (0x%x, %u, %u)\n",
0290                result.eth_protocol, result.ip_protocol,
0291                result.bind_inany);
0292         printf("expected: (0x%x, %u, %u)\n",
0293                expected.eth_protocol, expected.ip_protocol,
0294                expected.bind_inany);
0295         RET_IF(1, "data_check result != expected",
0296                "bpf_prog_linum:%ld\n", get_linum());
0297     }
0298 
0299     RET_IF(!result.hash, "data_check result.hash empty",
0300            "result.hash:%u", result.hash);
0301 
0302     expected.len += cmd ? sizeof(*cmd) : 0;
0303     if (type == SOCK_STREAM)
0304         RET_IF(expected.len > result.len, "expected.len > result.len",
0305                "expected.len:%u result.len:%u bpf_prog_linum:%ld\n",
0306                expected.len, result.len, get_linum());
0307     else
0308         RET_IF(expected.len != result.len, "expected.len != result.len",
0309                "expected.len:%u result.len:%u bpf_prog_linum:%ld\n",
0310                expected.len, result.len, get_linum());
0311 }
0312 
0313 static const char *result_to_str(enum result res)
0314 {
0315     switch (res) {
0316     case DROP_ERR_INNER_MAP:
0317         return "DROP_ERR_INNER_MAP";
0318     case DROP_ERR_SKB_DATA:
0319         return "DROP_ERR_SKB_DATA";
0320     case DROP_ERR_SK_SELECT_REUSEPORT:
0321         return "DROP_ERR_SK_SELECT_REUSEPORT";
0322     case DROP_MISC:
0323         return "DROP_MISC";
0324     case PASS:
0325         return "PASS";
0326     case PASS_ERR_SK_SELECT_REUSEPORT:
0327         return "PASS_ERR_SK_SELECT_REUSEPORT";
0328     default:
0329         return "UNKNOWN";
0330     }
0331 }
0332 
0333 static void check_results(void)
0334 {
0335     __u32 results[NR_RESULTS];
0336     __u32 i, broken = 0;
0337     int err;
0338 
0339     for (i = 0; i < NR_RESULTS; i++) {
0340         err = bpf_map_lookup_elem(result_map, &i, &results[i]);
0341         RET_IF(err < 0, "lookup_elem(result_map)",
0342                "i:%u err:%d errno:%d\n", i, err, errno);
0343     }
0344 
0345     for (i = 0; i < NR_RESULTS; i++) {
0346         if (results[i] != expected_results[i]) {
0347             broken = i;
0348             break;
0349         }
0350     }
0351 
0352     if (i == NR_RESULTS)
0353         return;
0354 
0355     printf("unexpected result\n");
0356     printf(" result: [");
0357     printf("%u", results[0]);
0358     for (i = 1; i < NR_RESULTS; i++)
0359         printf(", %u", results[i]);
0360     printf("]\n");
0361 
0362     printf("expected: [");
0363     printf("%u", expected_results[0]);
0364     for (i = 1; i < NR_RESULTS; i++)
0365         printf(", %u", expected_results[i]);
0366     printf("]\n");
0367 
0368     printf("mismatch on %s (bpf_prog_linum:%ld)\n", result_to_str(broken),
0369            get_linum());
0370 
0371     CHECK_FAIL(true);
0372 }
0373 
0374 static int send_data(int type, sa_family_t family, void *data, size_t len,
0375              enum result expected)
0376 {
0377     union sa46 cli_sa;
0378     int fd, err;
0379 
0380     fd = socket(family, type, 0);
0381     RET_ERR(fd == -1, "socket()", "fd:%d errno:%d\n", fd, errno);
0382 
0383     sa46_init_loopback(&cli_sa, family);
0384     err = bind(fd, (struct sockaddr *)&cli_sa, sizeof(cli_sa));
0385     RET_ERR(fd == -1, "bind(cli_sa)", "err:%d errno:%d\n", err, errno);
0386 
0387     err = sendto(fd, data, len, MSG_FASTOPEN, (struct sockaddr *)&srv_sa,
0388              sizeof(srv_sa));
0389     RET_ERR(err != len && expected >= PASS,
0390         "sendto()", "family:%u err:%d errno:%d expected:%d\n",
0391         family, err, errno, expected);
0392 
0393     return fd;
0394 }
0395 
0396 static void do_test(int type, sa_family_t family, struct cmd *cmd,
0397             enum result expected)
0398 {
0399     int nev, srv_fd, cli_fd;
0400     struct epoll_event ev;
0401     struct cmd rcv_cmd;
0402     ssize_t nread;
0403 
0404     cli_fd = send_data(type, family, cmd, cmd ? sizeof(*cmd) : 0,
0405                expected);
0406     if (cli_fd < 0)
0407         return;
0408     nev = epoll_wait(epfd, &ev, 1, expected >= PASS ? 5 : 0);
0409     RET_IF((nev <= 0 && expected >= PASS) ||
0410            (nev > 0 && expected < PASS),
0411            "nev <> expected",
0412            "nev:%d expected:%d type:%d family:%d data:(%d, %d)\n",
0413            nev, expected, type, family,
0414            cmd ? cmd->reuseport_index : -1,
0415            cmd ? cmd->pass_on_failure : -1);
0416     check_results();
0417     check_data(type, family, cmd, cli_fd);
0418 
0419     if (expected < PASS)
0420         return;
0421 
0422     RET_IF(expected != PASS_ERR_SK_SELECT_REUSEPORT &&
0423            cmd->reuseport_index != ev.data.u32,
0424            "check cmd->reuseport_index",
0425            "cmd:(%u, %u) ev.data.u32:%u\n",
0426            cmd->pass_on_failure, cmd->reuseport_index, ev.data.u32);
0427 
0428     srv_fd = sk_fds[ev.data.u32];
0429     if (type == SOCK_STREAM) {
0430         int new_fd = accept(srv_fd, NULL, 0);
0431 
0432         RET_IF(new_fd == -1, "accept(srv_fd)",
0433                "ev.data.u32:%u new_fd:%d errno:%d\n",
0434                ev.data.u32, new_fd, errno);
0435 
0436         nread = recv(new_fd, &rcv_cmd, sizeof(rcv_cmd), MSG_DONTWAIT);
0437         RET_IF(nread != sizeof(rcv_cmd),
0438                "recv(new_fd)",
0439                "ev.data.u32:%u nread:%zd sizeof(rcv_cmd):%zu errno:%d\n",
0440                ev.data.u32, nread, sizeof(rcv_cmd), errno);
0441 
0442         close(new_fd);
0443     } else {
0444         nread = recv(srv_fd, &rcv_cmd, sizeof(rcv_cmd), MSG_DONTWAIT);
0445         RET_IF(nread != sizeof(rcv_cmd),
0446                "recv(sk_fds)",
0447                "ev.data.u32:%u nread:%zd sizeof(rcv_cmd):%zu errno:%d\n",
0448                ev.data.u32, nread, sizeof(rcv_cmd), errno);
0449     }
0450 
0451     close(cli_fd);
0452 }
0453 
0454 static void test_err_inner_map(int type, sa_family_t family)
0455 {
0456     struct cmd cmd = {
0457         .reuseport_index = 0,
0458         .pass_on_failure = 0,
0459     };
0460 
0461     expected_results[DROP_ERR_INNER_MAP]++;
0462     do_test(type, family, &cmd, DROP_ERR_INNER_MAP);
0463 }
0464 
0465 static void test_err_skb_data(int type, sa_family_t family)
0466 {
0467     expected_results[DROP_ERR_SKB_DATA]++;
0468     do_test(type, family, NULL, DROP_ERR_SKB_DATA);
0469 }
0470 
0471 static void test_err_sk_select_port(int type, sa_family_t family)
0472 {
0473     struct cmd cmd = {
0474         .reuseport_index = REUSEPORT_ARRAY_SIZE,
0475         .pass_on_failure = 0,
0476     };
0477 
0478     expected_results[DROP_ERR_SK_SELECT_REUSEPORT]++;
0479     do_test(type, family, &cmd, DROP_ERR_SK_SELECT_REUSEPORT);
0480 }
0481 
0482 static void test_pass(int type, sa_family_t family)
0483 {
0484     struct cmd cmd;
0485     int i;
0486 
0487     cmd.pass_on_failure = 0;
0488     for (i = 0; i < REUSEPORT_ARRAY_SIZE; i++) {
0489         expected_results[PASS]++;
0490         cmd.reuseport_index = i;
0491         do_test(type, family, &cmd, PASS);
0492     }
0493 }
0494 
0495 static void test_syncookie(int type, sa_family_t family)
0496 {
0497     int err, tmp_index = 1;
0498     struct cmd cmd = {
0499         .reuseport_index = 0,
0500         .pass_on_failure = 0,
0501     };
0502 
0503     /*
0504      * +1 for TCP-SYN and
0505      * +1 for the TCP-ACK (ack the syncookie)
0506      */
0507     expected_results[PASS] += 2;
0508     enable_syncookie();
0509     /*
0510      * Simulate TCP-SYN and TCP-ACK are handled by two different sk:
0511      * TCP-SYN: select sk_fds[tmp_index = 1] tmp_index is from the
0512      *          tmp_index_ovr_map
0513      * TCP-ACK: select sk_fds[reuseport_index = 0] reuseport_index
0514      *          is from the cmd.reuseport_index
0515      */
0516     err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero,
0517                   &tmp_index, BPF_ANY);
0518     RET_IF(err < 0, "update_elem(tmp_index_ovr_map, 0, 1)",
0519            "err:%d errno:%d\n", err, errno);
0520     do_test(type, family, &cmd, PASS);
0521     err = bpf_map_lookup_elem(tmp_index_ovr_map, &index_zero,
0522                   &tmp_index);
0523     RET_IF(err < 0 || tmp_index >= 0,
0524            "lookup_elem(tmp_index_ovr_map)",
0525            "err:%d errno:%d tmp_index:%d\n",
0526            err, errno, tmp_index);
0527     disable_syncookie();
0528 }
0529 
0530 static void test_pass_on_err(int type, sa_family_t family)
0531 {
0532     struct cmd cmd = {
0533         .reuseport_index = REUSEPORT_ARRAY_SIZE,
0534         .pass_on_failure = 1,
0535     };
0536 
0537     expected_results[PASS_ERR_SK_SELECT_REUSEPORT] += 1;
0538     do_test(type, family, &cmd, PASS_ERR_SK_SELECT_REUSEPORT);
0539 }
0540 
0541 static void test_detach_bpf(int type, sa_family_t family)
0542 {
0543 #ifdef SO_DETACH_REUSEPORT_BPF
0544     __u32 nr_run_before = 0, nr_run_after = 0, tmp, i;
0545     struct epoll_event ev;
0546     int cli_fd, err, nev;
0547     struct cmd cmd = {};
0548     int optvalue = 0;
0549 
0550     err = setsockopt(sk_fds[0], SOL_SOCKET, SO_DETACH_REUSEPORT_BPF,
0551              &optvalue, sizeof(optvalue));
0552     RET_IF(err == -1, "setsockopt(SO_DETACH_REUSEPORT_BPF)",
0553            "err:%d errno:%d\n", err, errno);
0554 
0555     err = setsockopt(sk_fds[1], SOL_SOCKET, SO_DETACH_REUSEPORT_BPF,
0556              &optvalue, sizeof(optvalue));
0557     RET_IF(err == 0 || errno != ENOENT,
0558            "setsockopt(SO_DETACH_REUSEPORT_BPF)",
0559            "err:%d errno:%d\n", err, errno);
0560 
0561     for (i = 0; i < NR_RESULTS; i++) {
0562         err = bpf_map_lookup_elem(result_map, &i, &tmp);
0563         RET_IF(err < 0, "lookup_elem(result_map)",
0564                "i:%u err:%d errno:%d\n", i, err, errno);
0565         nr_run_before += tmp;
0566     }
0567 
0568     cli_fd = send_data(type, family, &cmd, sizeof(cmd), PASS);
0569     if (cli_fd < 0)
0570         return;
0571     nev = epoll_wait(epfd, &ev, 1, 5);
0572     RET_IF(nev <= 0, "nev <= 0",
0573            "nev:%d expected:1 type:%d family:%d data:(0, 0)\n",
0574            nev,  type, family);
0575 
0576     for (i = 0; i < NR_RESULTS; i++) {
0577         err = bpf_map_lookup_elem(result_map, &i, &tmp);
0578         RET_IF(err < 0, "lookup_elem(result_map)",
0579                "i:%u err:%d errno:%d\n", i, err, errno);
0580         nr_run_after += tmp;
0581     }
0582 
0583     RET_IF(nr_run_before != nr_run_after,
0584            "nr_run_before != nr_run_after",
0585            "nr_run_before:%u nr_run_after:%u\n",
0586            nr_run_before, nr_run_after);
0587 
0588     close(cli_fd);
0589 #else
0590     test__skip();
0591 #endif
0592 }
0593 
0594 static void prepare_sk_fds(int type, sa_family_t family, bool inany)
0595 {
0596     const int first = REUSEPORT_ARRAY_SIZE - 1;
0597     int i, err, optval = 1;
0598     struct epoll_event ev;
0599     socklen_t addrlen;
0600 
0601     if (inany)
0602         sa46_init_inany(&srv_sa, family);
0603     else
0604         sa46_init_loopback(&srv_sa, family);
0605     addrlen = sizeof(srv_sa);
0606 
0607     /*
0608      * The sk_fds[] is filled from the back such that the order
0609      * is exactly opposite to the (struct sock_reuseport *)reuse->socks[].
0610      */
0611     for (i = first; i >= 0; i--) {
0612         sk_fds[i] = socket(family, type, 0);
0613         RET_IF(sk_fds[i] == -1, "socket()", "sk_fds[%d]:%d errno:%d\n",
0614                i, sk_fds[i], errno);
0615         err = setsockopt(sk_fds[i], SOL_SOCKET, SO_REUSEPORT,
0616                  &optval, sizeof(optval));
0617         RET_IF(err == -1, "setsockopt(SO_REUSEPORT)",
0618                "sk_fds[%d] err:%d errno:%d\n",
0619                i, err, errno);
0620 
0621         if (i == first) {
0622             err = setsockopt(sk_fds[i], SOL_SOCKET,
0623                      SO_ATTACH_REUSEPORT_EBPF,
0624                      &select_by_skb_data_prog,
0625                      sizeof(select_by_skb_data_prog));
0626             RET_IF(err < 0, "setsockopt(SO_ATTACH_REUEPORT_EBPF)",
0627                    "err:%d errno:%d\n", err, errno);
0628         }
0629 
0630         err = bind(sk_fds[i], (struct sockaddr *)&srv_sa, addrlen);
0631         RET_IF(err < 0, "bind()", "sk_fds[%d] err:%d errno:%d\n",
0632                i, err, errno);
0633 
0634         if (type == SOCK_STREAM) {
0635             err = listen(sk_fds[i], 10);
0636             RET_IF(err < 0, "listen()",
0637                    "sk_fds[%d] err:%d errno:%d\n",
0638                    i, err, errno);
0639         }
0640 
0641         err = bpf_map_update_elem(reuseport_array, &i, &sk_fds[i],
0642                       BPF_NOEXIST);
0643         RET_IF(err < 0, "update_elem(reuseport_array)",
0644                "sk_fds[%d] err:%d errno:%d\n", i, err, errno);
0645 
0646         if (i == first) {
0647             socklen_t addrlen = sizeof(srv_sa);
0648 
0649             err = getsockname(sk_fds[i], (struct sockaddr *)&srv_sa,
0650                       &addrlen);
0651             RET_IF(err == -1, "getsockname()",
0652                    "sk_fds[%d] err:%d errno:%d\n", i, err, errno);
0653         }
0654     }
0655 
0656     epfd = epoll_create(1);
0657     RET_IF(epfd == -1, "epoll_create(1)",
0658            "epfd:%d errno:%d\n", epfd, errno);
0659 
0660     ev.events = EPOLLIN;
0661     for (i = 0; i < REUSEPORT_ARRAY_SIZE; i++) {
0662         ev.data.u32 = i;
0663         err = epoll_ctl(epfd, EPOLL_CTL_ADD, sk_fds[i], &ev);
0664         RET_IF(err, "epoll_ctl(EPOLL_CTL_ADD)", "sk_fds[%d]\n", i);
0665     }
0666 }
0667 
0668 static void setup_per_test(int type, sa_family_t family, bool inany,
0669                bool no_inner_map)
0670 {
0671     int ovr = -1, err;
0672 
0673     prepare_sk_fds(type, family, inany);
0674     err = bpf_map_update_elem(tmp_index_ovr_map, &index_zero, &ovr,
0675                   BPF_ANY);
0676     RET_IF(err < 0, "update_elem(tmp_index_ovr_map, 0, -1)",
0677            "err:%d errno:%d\n", err, errno);
0678 
0679     /* Install reuseport_array to outer_map? */
0680     if (no_inner_map)
0681         return;
0682 
0683     err = bpf_map_update_elem(outer_map, &index_zero, &reuseport_array,
0684                   BPF_ANY);
0685     RET_IF(err < 0, "update_elem(outer_map, 0, reuseport_array)",
0686            "err:%d errno:%d\n", err, errno);
0687 }
0688 
0689 static void cleanup_per_test(bool no_inner_map)
0690 {
0691     int i, err, zero = 0;
0692 
0693     memset(expected_results, 0, sizeof(expected_results));
0694 
0695     for (i = 0; i < NR_RESULTS; i++) {
0696         err = bpf_map_update_elem(result_map, &i, &zero, BPF_ANY);
0697         RET_IF(err, "reset elem in result_map",
0698                "i:%u err:%d errno:%d\n", i, err, errno);
0699     }
0700 
0701     err = bpf_map_update_elem(linum_map, &zero, &zero, BPF_ANY);
0702     RET_IF(err, "reset line number in linum_map", "err:%d errno:%d\n",
0703            err, errno);
0704 
0705     for (i = 0; i < REUSEPORT_ARRAY_SIZE; i++)
0706         close(sk_fds[i]);
0707     close(epfd);
0708 
0709     /* Delete reuseport_array from outer_map? */
0710     if (no_inner_map)
0711         return;
0712 
0713     err = bpf_map_delete_elem(outer_map, &index_zero);
0714     RET_IF(err < 0, "delete_elem(outer_map)",
0715            "err:%d errno:%d\n", err, errno);
0716 }
0717 
0718 static void cleanup(void)
0719 {
0720     if (outer_map >= 0) {
0721         close(outer_map);
0722         outer_map = -1;
0723     }
0724 
0725     if (reuseport_array >= 0) {
0726         close(reuseport_array);
0727         reuseport_array = -1;
0728     }
0729 
0730     if (obj) {
0731         bpf_object__close(obj);
0732         obj = NULL;
0733     }
0734 
0735     memset(expected_results, 0, sizeof(expected_results));
0736 }
0737 
0738 static const char *maptype_str(enum bpf_map_type type)
0739 {
0740     switch (type) {
0741     case BPF_MAP_TYPE_REUSEPORT_SOCKARRAY:
0742         return "reuseport_sockarray";
0743     case BPF_MAP_TYPE_SOCKMAP:
0744         return "sockmap";
0745     case BPF_MAP_TYPE_SOCKHASH:
0746         return "sockhash";
0747     default:
0748         return "unknown";
0749     }
0750 }
0751 
0752 static const char *family_str(sa_family_t family)
0753 {
0754     switch (family) {
0755     case AF_INET:
0756         return "IPv4";
0757     case AF_INET6:
0758         return "IPv6";
0759     default:
0760         return "unknown";
0761     }
0762 }
0763 
0764 static const char *sotype_str(int sotype)
0765 {
0766     switch (sotype) {
0767     case SOCK_STREAM:
0768         return "TCP";
0769     case SOCK_DGRAM:
0770         return "UDP";
0771     default:
0772         return "unknown";
0773     }
0774 }
0775 
0776 #define TEST_INIT(fn_, ...) { .fn = fn_, .name = #fn_, __VA_ARGS__ }
0777 
0778 static void test_config(int sotype, sa_family_t family, bool inany)
0779 {
0780     const struct test {
0781         void (*fn)(int sotype, sa_family_t family);
0782         const char *name;
0783         bool no_inner_map;
0784         int need_sotype;
0785     } tests[] = {
0786         TEST_INIT(test_err_inner_map,
0787               .no_inner_map = true),
0788         TEST_INIT(test_err_skb_data),
0789         TEST_INIT(test_err_sk_select_port),
0790         TEST_INIT(test_pass),
0791         TEST_INIT(test_syncookie,
0792               .need_sotype = SOCK_STREAM),
0793         TEST_INIT(test_pass_on_err),
0794         TEST_INIT(test_detach_bpf),
0795     };
0796     char s[MAX_TEST_NAME];
0797     const struct test *t;
0798 
0799     for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
0800         if (t->need_sotype && t->need_sotype != sotype)
0801             continue; /* test not compatible with socket type */
0802 
0803         snprintf(s, sizeof(s), "%s %s/%s %s %s",
0804              maptype_str(inner_map_type),
0805              family_str(family), sotype_str(sotype),
0806              inany ? "INANY" : "LOOPBACK", t->name);
0807 
0808         if (!test__start_subtest(s))
0809             continue;
0810 
0811         setup_per_test(sotype, family, inany, t->no_inner_map);
0812         t->fn(sotype, family);
0813         cleanup_per_test(t->no_inner_map);
0814     }
0815 }
0816 
0817 #define BIND_INANY true
0818 
0819 static void test_all(void)
0820 {
0821     const struct config {
0822         int sotype;
0823         sa_family_t family;
0824         bool inany;
0825     } configs[] = {
0826         { SOCK_STREAM, AF_INET },
0827         { SOCK_STREAM, AF_INET, BIND_INANY },
0828         { SOCK_STREAM, AF_INET6 },
0829         { SOCK_STREAM, AF_INET6, BIND_INANY },
0830         { SOCK_DGRAM, AF_INET },
0831         { SOCK_DGRAM, AF_INET6 },
0832     };
0833     const struct config *c;
0834 
0835     for (c = configs; c < configs + ARRAY_SIZE(configs); c++)
0836         test_config(c->sotype, c->family, c->inany);
0837 }
0838 
0839 void test_map_type(enum bpf_map_type mt)
0840 {
0841     if (create_maps(mt))
0842         goto out;
0843     if (prepare_bpf_obj())
0844         goto out;
0845 
0846     test_all();
0847 out:
0848     cleanup();
0849 }
0850 
0851 void serial_test_select_reuseport(void)
0852 {
0853     saved_tcp_fo = read_int_sysctl(TCP_FO_SYSCTL);
0854     if (saved_tcp_fo < 0)
0855         goto out;
0856     saved_tcp_syncookie = read_int_sysctl(TCP_SYNCOOKIE_SYSCTL);
0857     if (saved_tcp_syncookie < 0)
0858         goto out;
0859 
0860     if (enable_fastopen())
0861         goto out;
0862     if (disable_syncookie())
0863         goto out;
0864 
0865     test_map_type(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
0866     test_map_type(BPF_MAP_TYPE_SOCKMAP);
0867     test_map_type(BPF_MAP_TYPE_SOCKHASH);
0868 out:
0869     restore_sysctls();
0870 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!