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 "bpf_dctcp.skel.h" 8 #include "bpf_cubic.skel.h" 9 #include "bpf_tcp_nogpl.skel.h" 10 11 #define min(a, b) ((a) < (b) ? (a) : (b)) 12 13 static const unsigned int total_bytes = 10 * 1024 * 1024; 14 static const struct timeval timeo_sec = { .tv_sec = 10 }; 15 static const size_t timeo_optlen = sizeof(timeo_sec); 16 static int expected_stg = 0xeB9F; 17 static int stop, duration; 18 19 static int settimeo(int fd) 20 { 21 int err; 22 23 err = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo_sec, 24 timeo_optlen); 25 if (CHECK(err == -1, "setsockopt(fd, SO_RCVTIMEO)", "errno:%d\n", 26 errno)) 27 return -1; 28 29 err = setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo_sec, 30 timeo_optlen); 31 if (CHECK(err == -1, "setsockopt(fd, SO_SNDTIMEO)", "errno:%d\n", 32 errno)) 33 return -1; 34 35 return 0; 36 } 37 38 static int settcpca(int fd, const char *tcp_ca) 39 { 40 int err; 41 42 err = setsockopt(fd, IPPROTO_TCP, TCP_CONGESTION, tcp_ca, strlen(tcp_ca)); 43 if (CHECK(err == -1, "setsockopt(fd, TCP_CONGESTION)", "errno:%d\n", 44 errno)) 45 return -1; 46 47 return 0; 48 } 49 50 static void *server(void *arg) 51 { 52 int lfd = (int)(long)arg, err = 0, fd; 53 ssize_t nr_sent = 0, bytes = 0; 54 char batch[1500]; 55 56 fd = accept(lfd, NULL, NULL); 57 while (fd == -1) { 58 if (errno == EINTR) 59 continue; 60 err = -errno; 61 goto done; 62 } 63 64 if (settimeo(fd)) { 65 err = -errno; 66 goto done; 67 } 68 69 while (bytes < total_bytes && !READ_ONCE(stop)) { 70 nr_sent = send(fd, &batch, 71 min(total_bytes - bytes, sizeof(batch)), 0); 72 if (nr_sent == -1 && errno == EINTR) 73 continue; 74 if (nr_sent == -1) { 75 err = -errno; 76 break; 77 } 78 bytes += nr_sent; 79 } 80 81 CHECK(bytes != total_bytes, "send", "%zd != %u nr_sent:%zd errno:%d\n", 82 bytes, total_bytes, nr_sent, errno); 83 84 done: 85 if (fd != -1) 86 close(fd); 87 if (err) { 88 WRITE_ONCE(stop, 1); 89 return ERR_PTR(err); 90 } 91 return NULL; 92 } 93 94 static void do_test(const char *tcp_ca, const struct bpf_map *sk_stg_map) 95 { 96 struct sockaddr_in6 sa6 = {}; 97 ssize_t nr_recv = 0, bytes = 0; 98 int lfd = -1, fd = -1; 99 pthread_t srv_thread; 100 socklen_t addrlen = sizeof(sa6); 101 void *thread_ret; 102 char batch[1500]; 103 int err; 104 105 WRITE_ONCE(stop, 0); 106 107 lfd = socket(AF_INET6, SOCK_STREAM, 0); 108 if (CHECK(lfd == -1, "socket", "errno:%d\n", errno)) 109 return; 110 fd = socket(AF_INET6, SOCK_STREAM, 0); 111 if (CHECK(fd == -1, "socket", "errno:%d\n", errno)) { 112 close(lfd); 113 return; 114 } 115 116 if (settcpca(lfd, tcp_ca) || settcpca(fd, tcp_ca) || 117 settimeo(lfd) || settimeo(fd)) 118 goto done; 119 120 /* bind, listen and start server thread to accept */ 121 sa6.sin6_family = AF_INET6; 122 sa6.sin6_addr = in6addr_loopback; 123 err = bind(lfd, (struct sockaddr *)&sa6, addrlen); 124 if (CHECK(err == -1, "bind", "errno:%d\n", errno)) 125 goto done; 126 err = getsockname(lfd, (struct sockaddr *)&sa6, &addrlen); 127 if (CHECK(err == -1, "getsockname", "errno:%d\n", errno)) 128 goto done; 129 err = listen(lfd, 1); 130 if (CHECK(err == -1, "listen", "errno:%d\n", errno)) 131 goto done; 132 133 if (sk_stg_map) { 134 err = bpf_map_update_elem(bpf_map__fd(sk_stg_map), &fd, 135 &expected_stg, BPF_NOEXIST); 136 if (CHECK(err, "bpf_map_update_elem(sk_stg_map)", 137 "err:%d errno:%d\n", err, errno)) 138 goto done; 139 } 140 141 /* connect to server */ 142 err = connect(fd, (struct sockaddr *)&sa6, addrlen); 143 if (CHECK(err == -1, "connect", "errno:%d\n", errno)) 144 goto done; 145 146 if (sk_stg_map) { 147 int tmp_stg; 148 149 err = bpf_map_lookup_elem(bpf_map__fd(sk_stg_map), &fd, 150 &tmp_stg); 151 if (CHECK(!err || errno != ENOENT, 152 "bpf_map_lookup_elem(sk_stg_map)", 153 "err:%d errno:%d\n", err, errno)) 154 goto done; 155 } 156 157 err = pthread_create(&srv_thread, NULL, server, (void *)(long)lfd); 158 if (CHECK(err != 0, "pthread_create", "err:%d errno:%d\n", err, errno)) 159 goto done; 160 161 /* recv total_bytes */ 162 while (bytes < total_bytes && !READ_ONCE(stop)) { 163 nr_recv = recv(fd, &batch, 164 min(total_bytes - bytes, sizeof(batch)), 0); 165 if (nr_recv == -1 && errno == EINTR) 166 continue; 167 if (nr_recv == -1) 168 break; 169 bytes += nr_recv; 170 } 171 172 CHECK(bytes != total_bytes, "recv", "%zd != %u nr_recv:%zd errno:%d\n", 173 bytes, total_bytes, nr_recv, errno); 174 175 WRITE_ONCE(stop, 1); 176 pthread_join(srv_thread, &thread_ret); 177 CHECK(IS_ERR(thread_ret), "pthread_join", "thread_ret:%ld", 178 PTR_ERR(thread_ret)); 179 done: 180 close(lfd); 181 close(fd); 182 } 183 184 static void test_cubic(void) 185 { 186 struct bpf_cubic *cubic_skel; 187 struct bpf_link *link; 188 189 cubic_skel = bpf_cubic__open_and_load(); 190 if (CHECK(!cubic_skel, "bpf_cubic__open_and_load", "failed\n")) 191 return; 192 193 link = bpf_map__attach_struct_ops(cubic_skel->maps.cubic); 194 if (CHECK(IS_ERR(link), "bpf_map__attach_struct_ops", "err:%ld\n", 195 PTR_ERR(link))) { 196 bpf_cubic__destroy(cubic_skel); 197 return; 198 } 199 200 do_test("bpf_cubic", NULL); 201 202 bpf_link__destroy(link); 203 bpf_cubic__destroy(cubic_skel); 204 } 205 206 static void test_dctcp(void) 207 { 208 struct bpf_dctcp *dctcp_skel; 209 struct bpf_link *link; 210 211 dctcp_skel = bpf_dctcp__open_and_load(); 212 if (CHECK(!dctcp_skel, "bpf_dctcp__open_and_load", "failed\n")) 213 return; 214 215 link = bpf_map__attach_struct_ops(dctcp_skel->maps.dctcp); 216 if (CHECK(IS_ERR(link), "bpf_map__attach_struct_ops", "err:%ld\n", 217 PTR_ERR(link))) { 218 bpf_dctcp__destroy(dctcp_skel); 219 return; 220 } 221 222 do_test("bpf_dctcp", dctcp_skel->maps.sk_stg_map); 223 CHECK(dctcp_skel->bss->stg_result != expected_stg, 224 "Unexpected stg_result", "stg_result (%x) != expected_stg (%x)\n", 225 dctcp_skel->bss->stg_result, expected_stg); 226 227 bpf_link__destroy(link); 228 bpf_dctcp__destroy(dctcp_skel); 229 } 230 231 static char *err_str; 232 static bool found; 233 234 static int libbpf_debug_print(enum libbpf_print_level level, 235 const char *format, va_list args) 236 { 237 char *log_buf; 238 239 if (level != LIBBPF_WARN || 240 strcmp(format, "libbpf: \n%s\n")) { 241 vprintf(format, args); 242 return 0; 243 } 244 245 log_buf = va_arg(args, char *); 246 if (!log_buf) 247 goto out; 248 if (err_str && strstr(log_buf, err_str) != NULL) 249 found = true; 250 out: 251 printf(format, log_buf); 252 return 0; 253 } 254 255 static void test_invalid_license(void) 256 { 257 libbpf_print_fn_t old_print_fn; 258 struct bpf_tcp_nogpl *skel; 259 260 err_str = "struct ops programs must have a GPL compatible license"; 261 found = false; 262 old_print_fn = libbpf_set_print(libbpf_debug_print); 263 264 skel = bpf_tcp_nogpl__open_and_load(); 265 ASSERT_NULL(skel, "bpf_tcp_nogpl"); 266 ASSERT_EQ(found, true, "expected_err_msg"); 267 268 bpf_tcp_nogpl__destroy(skel); 269 libbpf_set_print(old_print_fn); 270 } 271 272 void test_bpf_tcp_ca(void) 273 { 274 if (test__start_subtest("dctcp")) 275 test_dctcp(); 276 if (test__start_subtest("cubic")) 277 test_cubic(); 278 if (test__start_subtest("invalid_license")) 279 test_invalid_license(); 280 } 281