This source file includes following definitions.
- connect_to_server
- verify_sockopt
- server_thread
- start_server
- prog_attach
- run_test
- test_sockopt_inherit
1
2 #include <test_progs.h>
3 #include "cgroup_helpers.h"
4
5 #define SOL_CUSTOM 0xdeadbeef
6 #define CUSTOM_INHERIT1 0
7 #define CUSTOM_INHERIT2 1
8 #define CUSTOM_LISTENER 2
9
10 static int connect_to_server(int server_fd)
11 {
12 struct sockaddr_storage addr;
13 socklen_t len = sizeof(addr);
14 int fd;
15
16 fd = socket(AF_INET, SOCK_STREAM, 0);
17 if (fd < 0) {
18 log_err("Failed to create client socket");
19 return -1;
20 }
21
22 if (getsockname(server_fd, (struct sockaddr *)&addr, &len)) {
23 log_err("Failed to get server addr");
24 goto out;
25 }
26
27 if (connect(fd, (const struct sockaddr *)&addr, len) < 0) {
28 log_err("Fail to connect to server");
29 goto out;
30 }
31
32 return fd;
33
34 out:
35 close(fd);
36 return -1;
37 }
38
39 static int verify_sockopt(int fd, int optname, const char *msg, char expected)
40 {
41 socklen_t optlen = 1;
42 char buf = 0;
43 int err;
44
45 err = getsockopt(fd, SOL_CUSTOM, optname, &buf, &optlen);
46 if (err) {
47 log_err("%s: failed to call getsockopt", msg);
48 return 1;
49 }
50
51 printf("%s %d: got=0x%x ? expected=0x%x\n", msg, optname, buf, expected);
52
53 if (buf != expected) {
54 log_err("%s: unexpected getsockopt value %d != %d", msg,
55 buf, expected);
56 return 1;
57 }
58
59 return 0;
60 }
61
62 static pthread_mutex_t server_started_mtx = PTHREAD_MUTEX_INITIALIZER;
63 static pthread_cond_t server_started = PTHREAD_COND_INITIALIZER;
64
65 static void *server_thread(void *arg)
66 {
67 struct sockaddr_storage addr;
68 socklen_t len = sizeof(addr);
69 int fd = *(int *)arg;
70 int client_fd;
71 int err = 0;
72
73 err = listen(fd, 1);
74
75 pthread_mutex_lock(&server_started_mtx);
76 pthread_cond_signal(&server_started);
77 pthread_mutex_unlock(&server_started_mtx);
78
79 if (CHECK_FAIL(err < 0)) {
80 perror("Failed to listed on socket");
81 return NULL;
82 }
83
84 err += verify_sockopt(fd, CUSTOM_INHERIT1, "listen", 1);
85 err += verify_sockopt(fd, CUSTOM_INHERIT2, "listen", 1);
86 err += verify_sockopt(fd, CUSTOM_LISTENER, "listen", 1);
87
88 client_fd = accept(fd, (struct sockaddr *)&addr, &len);
89 if (CHECK_FAIL(client_fd < 0)) {
90 perror("Failed to accept client");
91 return NULL;
92 }
93
94 err += verify_sockopt(client_fd, CUSTOM_INHERIT1, "accept", 1);
95 err += verify_sockopt(client_fd, CUSTOM_INHERIT2, "accept", 1);
96 err += verify_sockopt(client_fd, CUSTOM_LISTENER, "accept", 0);
97
98 close(client_fd);
99
100 return (void *)(long)err;
101 }
102
103 static int start_server(void)
104 {
105 struct sockaddr_in addr = {
106 .sin_family = AF_INET,
107 .sin_addr.s_addr = htonl(INADDR_LOOPBACK),
108 };
109 char buf;
110 int err;
111 int fd;
112 int i;
113
114 fd = socket(AF_INET, SOCK_STREAM, 0);
115 if (fd < 0) {
116 log_err("Failed to create server socket");
117 return -1;
118 }
119
120 for (i = CUSTOM_INHERIT1; i <= CUSTOM_LISTENER; i++) {
121 buf = 0x01;
122 err = setsockopt(fd, SOL_CUSTOM, i, &buf, 1);
123 if (err) {
124 log_err("Failed to call setsockopt(%d)", i);
125 close(fd);
126 return -1;
127 }
128 }
129
130 if (bind(fd, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {
131 log_err("Failed to bind socket");
132 close(fd);
133 return -1;
134 }
135
136 return fd;
137 }
138
139 static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title)
140 {
141 enum bpf_attach_type attach_type;
142 enum bpf_prog_type prog_type;
143 struct bpf_program *prog;
144 int err;
145
146 err = libbpf_prog_type_by_name(title, &prog_type, &attach_type);
147 if (err) {
148 log_err("Failed to deduct types for %s BPF program", title);
149 return -1;
150 }
151
152 prog = bpf_object__find_program_by_title(obj, title);
153 if (!prog) {
154 log_err("Failed to find %s BPF program", title);
155 return -1;
156 }
157
158 err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd,
159 attach_type, 0);
160 if (err) {
161 log_err("Failed to attach %s BPF program", title);
162 return -1;
163 }
164
165 return 0;
166 }
167
168 static void run_test(int cgroup_fd)
169 {
170 struct bpf_prog_load_attr attr = {
171 .file = "./sockopt_inherit.o",
172 };
173 int server_fd = -1, client_fd;
174 struct bpf_object *obj;
175 void *server_err;
176 pthread_t tid;
177 int ignored;
178 int err;
179
180 err = bpf_prog_load_xattr(&attr, &obj, &ignored);
181 if (CHECK_FAIL(err))
182 return;
183
184 err = prog_attach(obj, cgroup_fd, "cgroup/getsockopt");
185 if (CHECK_FAIL(err))
186 goto close_bpf_object;
187
188 err = prog_attach(obj, cgroup_fd, "cgroup/setsockopt");
189 if (CHECK_FAIL(err))
190 goto close_bpf_object;
191
192 server_fd = start_server();
193 if (CHECK_FAIL(server_fd < 0))
194 goto close_bpf_object;
195
196 if (CHECK_FAIL(pthread_create(&tid, NULL, server_thread,
197 (void *)&server_fd)))
198 goto close_server_fd;
199
200 pthread_mutex_lock(&server_started_mtx);
201 pthread_cond_wait(&server_started, &server_started_mtx);
202 pthread_mutex_unlock(&server_started_mtx);
203
204 client_fd = connect_to_server(server_fd);
205 if (CHECK_FAIL(client_fd < 0))
206 goto close_server_fd;
207
208 CHECK_FAIL(verify_sockopt(client_fd, CUSTOM_INHERIT1, "connect", 0));
209 CHECK_FAIL(verify_sockopt(client_fd, CUSTOM_INHERIT2, "connect", 0));
210 CHECK_FAIL(verify_sockopt(client_fd, CUSTOM_LISTENER, "connect", 0));
211
212 pthread_join(tid, &server_err);
213
214 err = (int)(long)server_err;
215 CHECK_FAIL(err);
216
217 close(client_fd);
218
219 close_server_fd:
220 close(server_fd);
221 close_bpf_object:
222 bpf_object__close(obj);
223 }
224
225 void test_sockopt_inherit(void)
226 {
227 int cgroup_fd;
228
229 cgroup_fd = test__join_cgroup("/sockopt_inherit");
230 if (CHECK_FAIL(cgroup_fd < 0))
231 return;
232
233 run_test(cgroup_fd);
234 close(cgroup_fd);
235 }