1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2021 Facebook */
3 #define _GNU_SOURCE
4 #include <sched.h>
5 #include <test_progs.h>
6 #include "network_helpers.h"
7 #include "bpf_dctcp.skel.h"
8 #include "bpf_cubic.skel.h"
9 #include "bpf_iter_setsockopt.skel.h"
10
11 static int create_netns(void)
12 {
13 if (!ASSERT_OK(unshare(CLONE_NEWNET), "create netns"))
14 return -1;
15
16 if (!ASSERT_OK(system("ip link set dev lo up"), "bring up lo"))
17 return -1;
18
19 return 0;
20 }
21
22 static unsigned int set_bpf_cubic(int *fds, unsigned int nr_fds)
23 {
24 unsigned int i;
25
26 for (i = 0; i < nr_fds; i++) {
27 if (setsockopt(fds[i], SOL_TCP, TCP_CONGESTION, "bpf_cubic",
28 sizeof("bpf_cubic")))
29 return i;
30 }
31
32 return nr_fds;
33 }
34
35 static unsigned int check_bpf_dctcp(int *fds, unsigned int nr_fds)
36 {
37 char tcp_cc[16];
38 socklen_t optlen = sizeof(tcp_cc);
39 unsigned int i;
40
41 for (i = 0; i < nr_fds; i++) {
42 if (getsockopt(fds[i], SOL_TCP, TCP_CONGESTION,
43 tcp_cc, &optlen) ||
44 strcmp(tcp_cc, "bpf_dctcp"))
45 return i;
46 }
47
48 return nr_fds;
49 }
50
51 static int *make_established(int listen_fd, unsigned int nr_est,
52 int **paccepted_fds)
53 {
54 int *est_fds, *accepted_fds;
55 unsigned int i;
56
57 est_fds = malloc(sizeof(*est_fds) * nr_est);
58 if (!est_fds)
59 return NULL;
60
61 accepted_fds = malloc(sizeof(*accepted_fds) * nr_est);
62 if (!accepted_fds) {
63 free(est_fds);
64 return NULL;
65 }
66
67 for (i = 0; i < nr_est; i++) {
68 est_fds[i] = connect_to_fd(listen_fd, 0);
69 if (est_fds[i] == -1)
70 break;
71 if (set_bpf_cubic(&est_fds[i], 1) != 1) {
72 close(est_fds[i]);
73 break;
74 }
75
76 accepted_fds[i] = accept(listen_fd, NULL, 0);
77 if (accepted_fds[i] == -1) {
78 close(est_fds[i]);
79 break;
80 }
81 }
82
83 if (!ASSERT_EQ(i, nr_est, "create established fds")) {
84 free_fds(accepted_fds, i);
85 free_fds(est_fds, i);
86 return NULL;
87 }
88
89 *paccepted_fds = accepted_fds;
90 return est_fds;
91 }
92
93 static unsigned short get_local_port(int fd)
94 {
95 struct sockaddr_in6 addr;
96 socklen_t addrlen = sizeof(addr);
97
98 if (!getsockname(fd, (struct sockaddr *)&addr, &addrlen))
99 return ntohs(addr.sin6_port);
100
101 return 0;
102 }
103
104 static void do_bpf_iter_setsockopt(struct bpf_iter_setsockopt *iter_skel,
105 bool random_retry)
106 {
107 int *reuse_listen_fds = NULL, *accepted_fds = NULL, *est_fds = NULL;
108 unsigned int nr_reuse_listens = 256, nr_est = 256;
109 int err, iter_fd = -1, listen_fd = -1;
110 char buf;
111
112 /* Prepare non-reuseport listen_fd */
113 listen_fd = start_server(AF_INET6, SOCK_STREAM, "::1", 0, 0);
114 if (!ASSERT_GE(listen_fd, 0, "start_server"))
115 return;
116 if (!ASSERT_EQ(set_bpf_cubic(&listen_fd, 1), 1,
117 "set listen_fd to cubic"))
118 goto done;
119 iter_skel->bss->listen_hport = get_local_port(listen_fd);
120 if (!ASSERT_NEQ(iter_skel->bss->listen_hport, 0,
121 "get_local_port(listen_fd)"))
122 goto done;
123
124 /* Connect to non-reuseport listen_fd */
125 est_fds = make_established(listen_fd, nr_est, &accepted_fds);
126 if (!ASSERT_OK_PTR(est_fds, "create established"))
127 goto done;
128
129 /* Prepare reuseport listen fds */
130 reuse_listen_fds = start_reuseport_server(AF_INET6, SOCK_STREAM,
131 "::1", 0, 0,
132 nr_reuse_listens);
133 if (!ASSERT_OK_PTR(reuse_listen_fds, "start_reuseport_server"))
134 goto done;
135 if (!ASSERT_EQ(set_bpf_cubic(reuse_listen_fds, nr_reuse_listens),
136 nr_reuse_listens, "set reuse_listen_fds to cubic"))
137 goto done;
138 iter_skel->bss->reuse_listen_hport = get_local_port(reuse_listen_fds[0]);
139 if (!ASSERT_NEQ(iter_skel->bss->reuse_listen_hport, 0,
140 "get_local_port(reuse_listen_fds[0])"))
141 goto done;
142
143 /* Run bpf tcp iter to switch from bpf_cubic to bpf_dctcp */
144 iter_skel->bss->random_retry = random_retry;
145 iter_fd = bpf_iter_create(bpf_link__fd(iter_skel->links.change_tcp_cc));
146 if (!ASSERT_GE(iter_fd, 0, "create iter_fd"))
147 goto done;
148
149 while ((err = read(iter_fd, &buf, sizeof(buf))) == -1 &&
150 errno == EAGAIN)
151 ;
152 if (!ASSERT_OK(err, "read iter error"))
153 goto done;
154
155 /* Check reuseport listen fds for dctcp */
156 ASSERT_EQ(check_bpf_dctcp(reuse_listen_fds, nr_reuse_listens),
157 nr_reuse_listens,
158 "check reuse_listen_fds dctcp");
159
160 /* Check non reuseport listen fd for dctcp */
161 ASSERT_EQ(check_bpf_dctcp(&listen_fd, 1), 1,
162 "check listen_fd dctcp");
163
164 /* Check established fds for dctcp */
165 ASSERT_EQ(check_bpf_dctcp(est_fds, nr_est), nr_est,
166 "check est_fds dctcp");
167
168 /* Check accepted fds for dctcp */
169 ASSERT_EQ(check_bpf_dctcp(accepted_fds, nr_est), nr_est,
170 "check accepted_fds dctcp");
171
172 done:
173 if (iter_fd != -1)
174 close(iter_fd);
175 if (listen_fd != -1)
176 close(listen_fd);
177 free_fds(reuse_listen_fds, nr_reuse_listens);
178 free_fds(accepted_fds, nr_est);
179 free_fds(est_fds, nr_est);
180 }
181
182 void serial_test_bpf_iter_setsockopt(void)
183 {
184 struct bpf_iter_setsockopt *iter_skel = NULL;
185 struct bpf_cubic *cubic_skel = NULL;
186 struct bpf_dctcp *dctcp_skel = NULL;
187 struct bpf_link *cubic_link = NULL;
188 struct bpf_link *dctcp_link = NULL;
189
190 if (create_netns())
191 return;
192
193 /* Load iter_skel */
194 iter_skel = bpf_iter_setsockopt__open_and_load();
195 if (!ASSERT_OK_PTR(iter_skel, "iter_skel"))
196 return;
197 iter_skel->links.change_tcp_cc = bpf_program__attach_iter(iter_skel->progs.change_tcp_cc, NULL);
198 if (!ASSERT_OK_PTR(iter_skel->links.change_tcp_cc, "attach iter"))
199 goto done;
200
201 /* Load bpf_cubic */
202 cubic_skel = bpf_cubic__open_and_load();
203 if (!ASSERT_OK_PTR(cubic_skel, "cubic_skel"))
204 goto done;
205 cubic_link = bpf_map__attach_struct_ops(cubic_skel->maps.cubic);
206 if (!ASSERT_OK_PTR(cubic_link, "cubic_link"))
207 goto done;
208
209 /* Load bpf_dctcp */
210 dctcp_skel = bpf_dctcp__open_and_load();
211 if (!ASSERT_OK_PTR(dctcp_skel, "dctcp_skel"))
212 goto done;
213 dctcp_link = bpf_map__attach_struct_ops(dctcp_skel->maps.dctcp);
214 if (!ASSERT_OK_PTR(dctcp_link, "dctcp_link"))
215 goto done;
216
217 do_bpf_iter_setsockopt(iter_skel, true);
218 do_bpf_iter_setsockopt(iter_skel, false);
219
220 done:
221 bpf_link__destroy(cubic_link);
222 bpf_link__destroy(dctcp_link);
223 bpf_cubic__destroy(cubic_skel);
224 bpf_dctcp__destroy(dctcp_skel);
225 bpf_iter_setsockopt__destroy(iter_skel);
226 }
227
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.