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
settimeo(int fd)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
settcpca(int fd,const char * tcp_ca)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
server(void * arg)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
do_test(const char * tcp_ca,const struct bpf_map * sk_stg_map)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
test_cubic(void)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
test_dctcp(void)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
libbpf_debug_print(enum libbpf_print_level level,const char * format,va_list args)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
test_invalid_license(void)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
test_bpf_tcp_ca(void)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