1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2019 Facebook */ 3 4 #include <linux/err.h> 5 #include <netinet/tcp.h> 6 #include <test_progs.h> 7 #include "network_helpers.h" 8 #include "bpf_dctcp.skel.h" 9 #include "bpf_cubic.skel.h" 10 #include "bpf_tcp_nogpl.skel.h" 11 #include "bpf_dctcp_release.skel.h" 12 13 #define min(a, b) ((a) < (b) ? (a) : (b)) 14 15 #ifndef ENOTSUPP 16 #define ENOTSUPP 524 17 #endif 18 19 static const unsigned int total_bytes = 10 * 1024 * 1024; 20 static int expected_stg = 0xeB9F; 21 static int stop, duration; 22 23 static int settcpca(int fd, const char *tcp_ca) 24 { 25 int err; 26 27 err = setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, tcp_ca, strlen(tcp_ca)); 28 if (CHECK(err == -1, "setsockopt(fd, TCP_CONGESTION)", "errno:%d\n", 29 errno)) 30 return -1; 31 32 return 0; 33 } 34 35 static void *server(void *arg) 36 { 37 int lfd = (int)(long)arg, err = 0, fd; 38 ssize_t nr_sent = 0, bytes = 0; 39 char batch[1500]; 40 41 fd = accept(lfd, NULL, NULL); 42 while (fd == -1) { 43 if (errno == EINTR) 44 continue; 45 err = -errno; 46 goto done; 47 } 48 49 if (settimeo(fd, 0)) { 50 err = -errno; 51 goto done; 52 } 53 54 while (bytes < total_bytes && !READ_ONCE(stop)) { 55 nr_sent = send(fd, &batch, 56 min(total_bytes - bytes, sizeof(batch)), 0); 57 if (nr_sent == -1 && errno == EINTR) 58 continue; 59 if (nr_sent == -1) { 60 err = -errno; 61 break; 62 } 63 bytes += nr_sent; 64 } 65 66 CHECK(bytes != total_bytes, "send", "%zd != %u nr_sent:%zd errno:%d\n", 67 bytes, total_bytes, nr_sent, errno); 68 69 done: 70 if (fd >= 0) 71 close(fd); 72 if (err) { 73 WRITE_ONCE(stop, 1); 74 return ERR_PTR(err); 75 } 76 return NULL; 77 } 78 79 static void do_test(const char *tcp_ca, const struct bpf_map *sk_stg_map) 80 { 81 struct sockaddr_in6 sa6 = {}; 82 ssize_t nr_recv = 0, bytes = 0; 83 int lfd = -1, fd = -1; 84 pthread_t srv_thread; 85 socklen_t addrlen = sizeof(sa6); 86 void *thread_ret; 87 char batch[1500]; 88 int err; 89 90 WRITE_ONCE(stop, 0); 91 92 lfd = socket(AF_INET6, SOCK_STREAM, 0); 93 if (CHECK(lfd == -1, "socket", "errno:%d\n", errno)) 94 return; 95 fd = socket(AF_INET6, SOCK_STREAM, 0); 96 if (CHECK(fd == -1, "socket", "errno:%d\n", errno)) { 97 close(lfd); 98 return; 99 } 100 101 if (settcpca(lfd, tcp_ca) || settcpca(fd, tcp_ca) || 102 settimeo(lfd, 0) || settimeo(fd, 0)) 103 goto done; 104 105 /* bind, listen and start server thread to accept */ 106 sa6.sin6_family = AF_INET6; 107 sa6.sin6_addr = in6addr_loopback; 108 err = bind(lfd, (struct sockaddr *)&sa6, addrlen); 109 if (CHECK(err == -1, "bind", "errno:%d\n", errno)) 110 goto done; 111 err = getsockname(lfd, (struct sockaddr *)&sa6, &addrlen); 112 if (CHECK(err == -1, "getsockname", "errno:%d\n", errno)) 113 goto done; 114 err = listen(lfd, 1); 115 if (CHECK(err == -1, "listen", "errno:%d\n", errno)) 116 goto done; 117 118 if (sk_stg_map) { 119 err = bpf_map_update_elem(bpf_map__fd(sk_stg_map), &fd, 120 &expected_stg, BPF_NOEXIST); 121 if (CHECK(err, "bpf_map_update_elem(sk_stg_map)", 122 "err:%d errno:%d\n", err, errno)) 123 goto done; 124 } 125 126 /* connect to server */ 127 err = connect(fd, (struct sockaddr *)&sa6, addrlen); 128 if (CHECK(err == -1, "connect", "errno:%d\n", errno)) 129 goto done; 130 131 if (sk_stg_map) { 132 int tmp_stg; 133 134 err = bpf_map_lookup_elem(bpf_map__fd(sk_stg_map), &fd, 135 &tmp_stg); 136 if (CHECK(!err || errno != ENOENT, 137 "bpf_map_lookup_elem(sk_stg_map)", 138 "err:%d errno:%d\n", err, errno)) 139 goto done; 140 } 141 142 err = pthread_create(&srv_thread, NULL, server, (void *)(long)lfd); 143 if (CHECK(err != 0, "pthread_create", "err:%d errno:%d\n", err, errno)) 144 goto done; 145 146 /* recv total_bytes */ 147 while (bytes < total_bytes && !READ_ONCE(stop)) { 148 nr_recv = recv(fd, &batch, 149 min(total_bytes - bytes, sizeof(batch)), 0); 150 if (nr_recv == -1 && errno == EINTR) 151 continue; 152 if (nr_recv == -1) 153 break; 154 bytes += nr_recv; 155 } 156 157 CHECK(bytes != total_bytes, "recv", "%zd != %u nr_recv:%zd errno:%d\n", 158 bytes, total_bytes, nr_recv, errno); 159 160 WRITE_ONCE(stop, 1); 161 pthread_join(srv_thread, &thread_ret); 162 CHECK(IS_ERR(thread_ret), "pthread_join", "thread_ret:%ld", 163 PTR_ERR(thread_ret)); 164 done: 165 close(lfd); 166 close(fd); 167 } 168 169 static void test_cubic(void) 170 { 171 struct bpf_cubic *cubic_skel; 172 struct bpf_link *link; 173 174 cubic_skel = bpf_cubic__open_and_load(); 175 if (CHECK(!cubic_skel, "bpf_cubic__open_and_load", "failed\n")) 176 return; 177 178 link = bpf_map__attach_struct_ops(cubic_skel->maps.cubic); 179 if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) { 180 bpf_cubic__destroy(cubic_skel); 181 return; 182 } 183 184 do_test("bpf_cubic", NULL); 185 186 bpf_link__destroy(link); 187 bpf_cubic__destroy(cubic_skel); 188 } 189 190 static void test_dctcp(void) 191 { 192 struct bpf_dctcp *dctcp_skel; 193 struct bpf_link *link; 194 195 dctcp_skel = bpf_dctcp__open_and_load(); 196 if (CHECK(!dctcp_skel, "bpf_dctcp__open_and_load", "failed\n")) 197 return; 198 199 link = bpf_map__attach_struct_ops(dctcp_skel->maps.dctcp); 200 if (!ASSERT_OK_PTR(link, "bpf_map__attach_struct_ops")) { 201 bpf_dctcp__destroy(dctcp_skel); 202 return; 203 } 204 205 do_test("bpf_dctcp", dctcp_skel->maps.sk_stg_map); 206 CHECK(dctcp_skel->bss->stg_result != expected_stg, 207 "Unexpected stg_result", "stg_result (%x) != expected_stg (%x)\n", 208 dctcp_skel->bss->stg_result, expected_stg); 209 210 bpf_link__destroy(link); 211 bpf_dctcp__destroy(dctcp_skel); 212 } 213 214 static char *err_str; 215 static bool found; 216 217 static int libbpf_debug_print(enum libbpf_print_level level, 218 const char *format, va_list args) 219 { 220 const char *prog_name, *log_buf; 221 222 if (level != LIBBPF_WARN || 223 !strstr(format, "-- BEGIN PROG LOAD LOG --")) { 224 vprintf(format, args); 225 return 0; 226 } 227 228 prog_name = va_arg(args, char *); 229 log_buf = va_arg(args, char *); 230 if (!log_buf) 231 goto out; 232 if (err_str && strstr(log_buf, err_str) != NULL) 233 found = true; 234 out: 235 printf(format, prog_name, log_buf); 236 return 0; 237 } 238 239 static void test_invalid_license(void) 240 { 241 libbpf_print_fn_t old_print_fn; 242 struct bpf_tcp_nogpl *skel; 243 244 err_str = "struct ops programs must have a GPL compatible license"; 245 found = false; 246 old_print_fn = libbpf_set_print(libbpf_debug_print); 247 248 skel = bpf_tcp_nogpl__open_and_load(); 249 ASSERT_NULL(skel, "bpf_tcp_nogpl"); 250 ASSERT_EQ(found, true, "expected_err_msg"); 251 252 bpf_tcp_nogpl__destroy(skel); 253 libbpf_set_print(old_print_fn); 254 } 255 256 static void test_dctcp_fallback(void) 257 { 258 int err, lfd = -1, cli_fd = -1, srv_fd = -1; 259 struct network_helper_opts opts = { 260 .cc = "cubic", 261 }; 262 struct bpf_dctcp *dctcp_skel; 263 struct bpf_link *link = NULL; 264 char srv_cc[16]; 265 socklen_t cc_len = sizeof(srv_cc); 266 267 dctcp_skel = bpf_dctcp__open(); 268 if (!ASSERT_OK_PTR(dctcp_skel, "dctcp_skel")) 269 return; 270 strcpy(dctcp_skel->rodata->fallback, "cubic"); 271 if (!ASSERT_OK(bpf_dctcp__load(dctcp_skel), "bpf_dctcp__load")) 272 goto done; 273 274 link = bpf_map__attach_struct_ops(dctcp_skel->maps.dctcp); 275 if (!ASSERT_OK_PTR(link, "dctcp link")) 276 goto done; 277 278 lfd = start_server(AF_INET6, SOCK_STREAM, "::1", 0, 0); 279 if (!ASSERT_GE(lfd, 0, "lfd") || 280 !ASSERT_OK(settcpca(lfd, "bpf_dctcp"), "lfd=>bpf_dctcp")) 281 goto done; 282 283 cli_fd = connect_to_fd_opts(lfd, &opts); 284 if (!ASSERT_GE(cli_fd, 0, "cli_fd")) 285 goto done; 286 287 srv_fd = accept(lfd, NULL, 0); 288 if (!ASSERT_GE(srv_fd, 0, "srv_fd")) 289 goto done; 290 ASSERT_STREQ(dctcp_skel->bss->cc_res, "cubic", "cc_res"); 291 ASSERT_EQ(dctcp_skel->bss->tcp_cdg_res, -ENOTSUPP, "tcp_cdg_res"); 292 293 err = getsockopt(srv_fd, SOL_TCP, TCP_CONGESTION, srv_cc, &cc_len); 294 if (!ASSERT_OK(err, "getsockopt(srv_fd, TCP_CONGESTION)")) 295 goto done; 296 ASSERT_STREQ(srv_cc, "cubic", "srv_fd cc"); 297 298 done: 299 bpf_link__destroy(link); 300 bpf_dctcp__destroy(dctcp_skel); 301 if (lfd != -1) 302 close(lfd); 303 if (srv_fd != -1) 304 close(srv_fd); 305 if (cli_fd != -1) 306 close(cli_fd); 307 } 308 309 static void test_rel_setsockopt(void) 310 { 311 struct bpf_dctcp_release *rel_skel; 312 libbpf_print_fn_t old_print_fn; 313 314 err_str = "unknown func bpf_setsockopt"; 315 found = false; 316 317 old_print_fn = libbpf_set_print(libbpf_debug_print); 318 rel_skel = bpf_dctcp_release__open_and_load(); 319 libbpf_set_print(old_print_fn); 320 321 ASSERT_ERR_PTR(rel_skel, "rel_skel"); 322 ASSERT_TRUE(found, "expected_err_msg"); 323 324 bpf_dctcp_release__destroy(rel_skel); 325 } 326 327 void test_bpf_tcp_ca(void) 328 { 329 if (test__start_subtest("dctcp")) 330 test_dctcp(); 331 if (test__start_subtest("cubic")) 332 test_cubic(); 333 if (test__start_subtest("invalid_license")) 334 test_invalid_license(); 335 if (test__start_subtest("dctcp_fallback")) 336 test_dctcp_fallback(); 337 if (test__start_subtest("rel_setsockopt")) 338 test_rel_setsockopt(); 339 } 340