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