xref: /linux/tools/testing/selftests/bpf/prog_tests/sockmap_listen.c (revision d9104cec3e8fe4b458b74709853231385779001f)
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2020 Cloudflare
3 /*
4  * Test suite for SOCKMAP/SOCKHASH holding listening sockets.
5  * Covers:
6  *  1. BPF map operations - bpf_map_{update,lookup delete}_elem
7  *  2. BPF redirect helpers - bpf_{sk,msg}_redirect_map
8  *  3. BPF reuseport helper - bpf_sk_select_reuseport
9  */
10 
11 #include <linux/compiler.h>
12 #include <errno.h>
13 #include <error.h>
14 #include <limits.h>
15 #include <netinet/in.h>
16 #include <pthread.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <sys/select.h>
20 #include <unistd.h>
21 #include <linux/vm_sockets.h>
22 
23 #include <bpf/bpf.h>
24 #include <bpf/libbpf.h>
25 
26 #include "bpf_util.h"
27 #include "test_progs.h"
28 #include "test_sockmap_listen.skel.h"
29 
30 #include "sockmap_helpers.h"
31 
32 #define NO_FLAGS 0
33 
test_insert_invalid(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)34 static void test_insert_invalid(struct test_sockmap_listen *skel __always_unused,
35 				int family, int sotype, int mapfd)
36 {
37 	u32 key = 0;
38 	u64 value;
39 	int err;
40 
41 	value = -1;
42 	err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
43 	if (!err || errno != EINVAL)
44 		FAIL_ERRNO("map_update: expected EINVAL");
45 
46 	value = INT_MAX;
47 	err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
48 	if (!err || errno != EBADF)
49 		FAIL_ERRNO("map_update: expected EBADF");
50 }
51 
test_insert_opened(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)52 static void test_insert_opened(struct test_sockmap_listen *skel __always_unused,
53 			       int family, int sotype, int mapfd)
54 {
55 	u32 key = 0;
56 	u64 value;
57 	int err, s;
58 
59 	s = xsocket(family, sotype, 0);
60 	if (s == -1)
61 		return;
62 
63 	errno = 0;
64 	value = s;
65 	err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
66 	if (sotype == SOCK_STREAM) {
67 		if (!err || errno != EOPNOTSUPP)
68 			FAIL_ERRNO("map_update: expected EOPNOTSUPP");
69 	} else if (err)
70 		FAIL_ERRNO("map_update: expected success");
71 	xclose(s);
72 }
73 
test_insert_bound(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)74 static void test_insert_bound(struct test_sockmap_listen *skel __always_unused,
75 			      int family, int sotype, int mapfd)
76 {
77 	struct sockaddr_storage addr;
78 	socklen_t len = 0;
79 	u32 key = 0;
80 	u64 value;
81 	int err, s;
82 
83 	init_addr_loopback(family, &addr, &len);
84 
85 	s = xsocket(family, sotype, 0);
86 	if (s == -1)
87 		return;
88 
89 	err = xbind(s, sockaddr(&addr), len);
90 	if (err)
91 		goto close;
92 
93 	errno = 0;
94 	value = s;
95 	err = bpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
96 	if (!err || errno != EOPNOTSUPP)
97 		FAIL_ERRNO("map_update: expected EOPNOTSUPP");
98 close:
99 	xclose(s);
100 }
101 
test_insert(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)102 static void test_insert(struct test_sockmap_listen *skel __always_unused,
103 			int family, int sotype, int mapfd)
104 {
105 	u64 value;
106 	u32 key;
107 	int s;
108 
109 	s = socket_loopback(family, sotype);
110 	if (s < 0)
111 		return;
112 
113 	key = 0;
114 	value = s;
115 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
116 	xclose(s);
117 }
118 
test_delete_after_insert(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)119 static void test_delete_after_insert(struct test_sockmap_listen *skel __always_unused,
120 				     int family, int sotype, int mapfd)
121 {
122 	u64 value;
123 	u32 key;
124 	int s;
125 
126 	s = socket_loopback(family, sotype);
127 	if (s < 0)
128 		return;
129 
130 	key = 0;
131 	value = s;
132 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
133 	xbpf_map_delete_elem(mapfd, &key);
134 	xclose(s);
135 }
136 
test_delete_after_close(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)137 static void test_delete_after_close(struct test_sockmap_listen *skel __always_unused,
138 				    int family, int sotype, int mapfd)
139 {
140 	int err, s;
141 	u64 value;
142 	u32 key;
143 
144 	s = socket_loopback(family, sotype);
145 	if (s < 0)
146 		return;
147 
148 	key = 0;
149 	value = s;
150 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
151 
152 	xclose(s);
153 
154 	errno = 0;
155 	err = bpf_map_delete_elem(mapfd, &key);
156 	if (!err || (errno != EINVAL && errno != ENOENT))
157 		/* SOCKMAP and SOCKHASH return different error codes */
158 		FAIL_ERRNO("map_delete: expected EINVAL/EINVAL");
159 }
160 
test_lookup_after_insert(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)161 static void test_lookup_after_insert(struct test_sockmap_listen *skel __always_unused,
162 				     int family, int sotype, int mapfd)
163 {
164 	u64 cookie, value;
165 	socklen_t len;
166 	u32 key;
167 	int s;
168 
169 	s = socket_loopback(family, sotype);
170 	if (s < 0)
171 		return;
172 
173 	key = 0;
174 	value = s;
175 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
176 
177 	len = sizeof(cookie);
178 	xgetsockopt(s, SOL_SOCKET, SO_COOKIE, &cookie, &len);
179 
180 	xbpf_map_lookup_elem(mapfd, &key, &value);
181 
182 	if (value != cookie) {
183 		FAIL("map_lookup: have %#llx, want %#llx",
184 		     (unsigned long long)value, (unsigned long long)cookie);
185 	}
186 
187 	xclose(s);
188 }
189 
test_lookup_after_delete(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)190 static void test_lookup_after_delete(struct test_sockmap_listen *skel __always_unused,
191 				     int family, int sotype, int mapfd)
192 {
193 	int err, s;
194 	u64 value;
195 	u32 key;
196 
197 	s = socket_loopback(family, sotype);
198 	if (s < 0)
199 		return;
200 
201 	key = 0;
202 	value = s;
203 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
204 	xbpf_map_delete_elem(mapfd, &key);
205 
206 	errno = 0;
207 	err = bpf_map_lookup_elem(mapfd, &key, &value);
208 	if (!err || errno != ENOENT)
209 		FAIL_ERRNO("map_lookup: expected ENOENT");
210 
211 	xclose(s);
212 }
213 
test_lookup_32_bit_value(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)214 static void test_lookup_32_bit_value(struct test_sockmap_listen *skel __always_unused,
215 				     int family, int sotype, int mapfd)
216 {
217 	u32 key, value32;
218 	int err, s;
219 
220 	s = socket_loopback(family, sotype);
221 	if (s < 0)
222 		return;
223 
224 	mapfd = bpf_map_create(BPF_MAP_TYPE_SOCKMAP, NULL, sizeof(key),
225 			       sizeof(value32), 1, NULL);
226 	if (mapfd < 0) {
227 		FAIL_ERRNO("map_create");
228 		goto close;
229 	}
230 
231 	key = 0;
232 	value32 = s;
233 	xbpf_map_update_elem(mapfd, &key, &value32, BPF_NOEXIST);
234 
235 	errno = 0;
236 	err = bpf_map_lookup_elem(mapfd, &key, &value32);
237 	if (!err || errno != ENOSPC)
238 		FAIL_ERRNO("map_lookup: expected ENOSPC");
239 
240 	xclose(mapfd);
241 close:
242 	xclose(s);
243 }
244 
test_update_existing(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)245 static void test_update_existing(struct test_sockmap_listen *skel __always_unused,
246 				 int family, int sotype, int mapfd)
247 {
248 	int s1, s2;
249 	u64 value;
250 	u32 key;
251 
252 	s1 = socket_loopback(family, sotype);
253 	if (s1 < 0)
254 		return;
255 
256 	s2 = socket_loopback(family, sotype);
257 	if (s2 < 0)
258 		goto close_s1;
259 
260 	key = 0;
261 	value = s1;
262 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
263 
264 	value = s2;
265 	xbpf_map_update_elem(mapfd, &key, &value, BPF_EXIST);
266 	xclose(s2);
267 close_s1:
268 	xclose(s1);
269 }
270 
271 /* Exercise the code path where we destroy child sockets that never
272  * got accept()'ed, aka orphans, when parent socket gets closed.
273  */
do_destroy_orphan_child(int family,int sotype,int mapfd)274 static void do_destroy_orphan_child(int family, int sotype, int mapfd)
275 {
276 	struct sockaddr_storage addr;
277 	socklen_t len;
278 	int err, s, c;
279 	u64 value;
280 	u32 key;
281 
282 	s = socket_loopback(family, sotype);
283 	if (s < 0)
284 		return;
285 
286 	len = sizeof(addr);
287 	err = xgetsockname(s, sockaddr(&addr), &len);
288 	if (err)
289 		goto close_srv;
290 
291 	key = 0;
292 	value = s;
293 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
294 
295 	c = xsocket(family, sotype, 0);
296 	if (c == -1)
297 		goto close_srv;
298 
299 	xconnect(c, sockaddr(&addr), len);
300 	xclose(c);
301 close_srv:
302 	xclose(s);
303 }
304 
test_destroy_orphan_child(struct test_sockmap_listen * skel,int family,int sotype,int mapfd)305 static void test_destroy_orphan_child(struct test_sockmap_listen *skel,
306 				      int family, int sotype, int mapfd)
307 {
308 	int msg_verdict = bpf_program__fd(skel->progs.prog_msg_verdict);
309 	int skb_verdict = bpf_program__fd(skel->progs.prog_skb_verdict);
310 	const struct test {
311 		int progfd;
312 		enum bpf_attach_type atype;
313 	} tests[] = {
314 		{ -1, -1 },
315 		{ msg_verdict, BPF_SK_MSG_VERDICT },
316 		{ skb_verdict, BPF_SK_SKB_VERDICT },
317 	};
318 	const struct test *t;
319 
320 	for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
321 		if (t->progfd != -1 &&
322 		    xbpf_prog_attach(t->progfd, mapfd, t->atype, 0) != 0)
323 			return;
324 
325 		do_destroy_orphan_child(family, sotype, mapfd);
326 
327 		if (t->progfd != -1)
328 			xbpf_prog_detach2(t->progfd, mapfd, t->atype);
329 	}
330 }
331 
332 /* Perform a passive open after removing listening socket from SOCKMAP
333  * to ensure that callbacks get restored properly.
334  */
test_clone_after_delete(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)335 static void test_clone_after_delete(struct test_sockmap_listen *skel __always_unused,
336 				    int family, int sotype, int mapfd)
337 {
338 	struct sockaddr_storage addr;
339 	socklen_t len;
340 	int err, s, c;
341 	u64 value;
342 	u32 key;
343 
344 	s = socket_loopback(family, sotype);
345 	if (s < 0)
346 		return;
347 
348 	len = sizeof(addr);
349 	err = xgetsockname(s, sockaddr(&addr), &len);
350 	if (err)
351 		goto close_srv;
352 
353 	key = 0;
354 	value = s;
355 	xbpf_map_update_elem(mapfd, &key, &value, BPF_NOEXIST);
356 	xbpf_map_delete_elem(mapfd, &key);
357 
358 	c = xsocket(family, sotype, 0);
359 	if (c < 0)
360 		goto close_srv;
361 
362 	xconnect(c, sockaddr(&addr), len);
363 	xclose(c);
364 close_srv:
365 	xclose(s);
366 }
367 
368 /* Check that child socket that got created while parent was in a
369  * SOCKMAP, but got accept()'ed only after the parent has been removed
370  * from SOCKMAP, gets cloned without parent psock state or callbacks.
371  */
test_accept_after_delete(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)372 static void test_accept_after_delete(struct test_sockmap_listen *skel __always_unused,
373 				     int family, int sotype, int mapfd)
374 {
375 	struct sockaddr_storage addr;
376 	const u32 zero = 0;
377 	int err, s, c, p;
378 	socklen_t len;
379 	u64 value;
380 
381 	s = socket_loopback(family, sotype | SOCK_NONBLOCK);
382 	if (s == -1)
383 		return;
384 
385 	len = sizeof(addr);
386 	err = xgetsockname(s, sockaddr(&addr), &len);
387 	if (err)
388 		goto close_srv;
389 
390 	value = s;
391 	err = xbpf_map_update_elem(mapfd, &zero, &value, BPF_NOEXIST);
392 	if (err)
393 		goto close_srv;
394 
395 	c = xsocket(family, sotype, 0);
396 	if (c == -1)
397 		goto close_srv;
398 
399 	/* Create child while parent is in sockmap */
400 	err = xconnect(c, sockaddr(&addr), len);
401 	if (err)
402 		goto close_cli;
403 
404 	/* Remove parent from sockmap */
405 	err = xbpf_map_delete_elem(mapfd, &zero);
406 	if (err)
407 		goto close_cli;
408 
409 	p = xaccept_nonblock(s, NULL, NULL);
410 	if (p == -1)
411 		goto close_cli;
412 
413 	/* Check that child sk_user_data is not set */
414 	value = p;
415 	xbpf_map_update_elem(mapfd, &zero, &value, BPF_NOEXIST);
416 
417 	xclose(p);
418 close_cli:
419 	xclose(c);
420 close_srv:
421 	xclose(s);
422 }
423 
424 /* Check that child socket that got created and accepted while parent
425  * was in a SOCKMAP is cloned without parent psock state or callbacks.
426  */
test_accept_before_delete(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)427 static void test_accept_before_delete(struct test_sockmap_listen *skel __always_unused,
428 				      int family, int sotype, int mapfd)
429 {
430 	struct sockaddr_storage addr;
431 	const u32 zero = 0, one = 1;
432 	int err, s, c, p;
433 	socklen_t len;
434 	u64 value;
435 
436 	s = socket_loopback(family, sotype | SOCK_NONBLOCK);
437 	if (s == -1)
438 		return;
439 
440 	len = sizeof(addr);
441 	err = xgetsockname(s, sockaddr(&addr), &len);
442 	if (err)
443 		goto close_srv;
444 
445 	value = s;
446 	err = xbpf_map_update_elem(mapfd, &zero, &value, BPF_NOEXIST);
447 	if (err)
448 		goto close_srv;
449 
450 	c = xsocket(family, sotype, 0);
451 	if (c == -1)
452 		goto close_srv;
453 
454 	/* Create & accept child while parent is in sockmap */
455 	err = xconnect(c, sockaddr(&addr), len);
456 	if (err)
457 		goto close_cli;
458 
459 	p = xaccept_nonblock(s, NULL, NULL);
460 	if (p == -1)
461 		goto close_cli;
462 
463 	/* Check that child sk_user_data is not set */
464 	value = p;
465 	xbpf_map_update_elem(mapfd, &one, &value, BPF_NOEXIST);
466 
467 	xclose(p);
468 close_cli:
469 	xclose(c);
470 close_srv:
471 	xclose(s);
472 }
473 
474 struct connect_accept_ctx {
475 	int sockfd;
476 	unsigned int done;
477 	unsigned int nr_iter;
478 };
479 
is_thread_done(struct connect_accept_ctx * ctx)480 static bool is_thread_done(struct connect_accept_ctx *ctx)
481 {
482 	return READ_ONCE(ctx->done);
483 }
484 
connect_accept_thread(void * arg)485 static void *connect_accept_thread(void *arg)
486 {
487 	struct connect_accept_ctx *ctx = arg;
488 	struct sockaddr_storage addr;
489 	int family, socktype;
490 	socklen_t len;
491 	int err, i, s;
492 
493 	s = ctx->sockfd;
494 
495 	len = sizeof(addr);
496 	err = xgetsockname(s, sockaddr(&addr), &len);
497 	if (err)
498 		goto done;
499 
500 	len = sizeof(family);
501 	err = xgetsockopt(s, SOL_SOCKET, SO_DOMAIN, &family, &len);
502 	if (err)
503 		goto done;
504 
505 	len = sizeof(socktype);
506 	err = xgetsockopt(s, SOL_SOCKET, SO_TYPE, &socktype, &len);
507 	if (err)
508 		goto done;
509 
510 	for (i = 0; i < ctx->nr_iter; i++) {
511 		int c, p;
512 
513 		c = xsocket(family, socktype, 0);
514 		if (c < 0)
515 			break;
516 
517 		err = xconnect(c, (struct sockaddr *)&addr, sizeof(addr));
518 		if (err) {
519 			xclose(c);
520 			break;
521 		}
522 
523 		p = xaccept_nonblock(s, NULL, NULL);
524 		if (p < 0) {
525 			xclose(c);
526 			break;
527 		}
528 
529 		xclose(p);
530 		xclose(c);
531 	}
532 done:
533 	WRITE_ONCE(ctx->done, 1);
534 	return NULL;
535 }
536 
test_syn_recv_insert_delete(struct test_sockmap_listen * skel __always_unused,int family,int sotype,int mapfd)537 static void test_syn_recv_insert_delete(struct test_sockmap_listen *skel __always_unused,
538 					int family, int sotype, int mapfd)
539 {
540 	struct connect_accept_ctx ctx = { 0 };
541 	struct sockaddr_storage addr;
542 	socklen_t len;
543 	u32 zero = 0;
544 	pthread_t t;
545 	int err, s;
546 	u64 value;
547 
548 	s = socket_loopback(family, sotype | SOCK_NONBLOCK);
549 	if (s < 0)
550 		return;
551 
552 	len = sizeof(addr);
553 	err = xgetsockname(s, sockaddr(&addr), &len);
554 	if (err)
555 		goto close;
556 
557 	ctx.sockfd = s;
558 	ctx.nr_iter = 1000;
559 
560 	err = xpthread_create(&t, NULL, connect_accept_thread, &ctx);
561 	if (err)
562 		goto close;
563 
564 	value = s;
565 	while (!is_thread_done(&ctx)) {
566 		err = xbpf_map_update_elem(mapfd, &zero, &value, BPF_NOEXIST);
567 		if (err)
568 			break;
569 
570 		err = xbpf_map_delete_elem(mapfd, &zero);
571 		if (err)
572 			break;
573 	}
574 
575 	xpthread_join(t, NULL);
576 close:
577 	xclose(s);
578 }
579 
listen_thread(void * arg)580 static void *listen_thread(void *arg)
581 {
582 	struct sockaddr unspec = { AF_UNSPEC };
583 	struct connect_accept_ctx *ctx = arg;
584 	int err, i, s;
585 
586 	s = ctx->sockfd;
587 
588 	for (i = 0; i < ctx->nr_iter; i++) {
589 		err = xlisten(s, 1);
590 		if (err)
591 			break;
592 		err = xconnect(s, &unspec, sizeof(unspec));
593 		if (err)
594 			break;
595 	}
596 
597 	WRITE_ONCE(ctx->done, 1);
598 	return NULL;
599 }
600 
test_race_insert_listen(struct test_sockmap_listen * skel __always_unused,int family,int socktype,int mapfd)601 static void test_race_insert_listen(struct test_sockmap_listen *skel __always_unused,
602 				    int family, int socktype, int mapfd)
603 {
604 	struct connect_accept_ctx ctx = { 0 };
605 	const u32 zero = 0;
606 	const int one = 1;
607 	pthread_t t;
608 	int err, s;
609 	u64 value;
610 
611 	s = xsocket(family, socktype, 0);
612 	if (s < 0)
613 		return;
614 
615 	err = xsetsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
616 	if (err)
617 		goto close;
618 
619 	ctx.sockfd = s;
620 	ctx.nr_iter = 10000;
621 
622 	err = pthread_create(&t, NULL, listen_thread, &ctx);
623 	if (err)
624 		goto close;
625 
626 	value = s;
627 	while (!is_thread_done(&ctx)) {
628 		err = bpf_map_update_elem(mapfd, &zero, &value, BPF_NOEXIST);
629 		/* Expecting EOPNOTSUPP before listen() */
630 		if (err && errno != EOPNOTSUPP) {
631 			FAIL_ERRNO("map_update");
632 			break;
633 		}
634 
635 		err = bpf_map_delete_elem(mapfd, &zero);
636 		/* Expecting no entry after unhash on connect(AF_UNSPEC) */
637 		if (err && errno != EINVAL && errno != ENOENT) {
638 			FAIL_ERRNO("map_delete");
639 			break;
640 		}
641 	}
642 
643 	xpthread_join(t, NULL);
644 close:
645 	xclose(s);
646 }
647 
zero_verdict_count(int mapfd)648 static void zero_verdict_count(int mapfd)
649 {
650 	unsigned int zero = 0;
651 	int key;
652 
653 	key = SK_DROP;
654 	xbpf_map_update_elem(mapfd, &key, &zero, BPF_ANY);
655 	key = SK_PASS;
656 	xbpf_map_update_elem(mapfd, &key, &zero, BPF_ANY);
657 }
658 
659 enum redir_mode {
660 	REDIR_INGRESS,
661 	REDIR_EGRESS,
662 };
663 
redir_mode_str(enum redir_mode mode)664 static const char *redir_mode_str(enum redir_mode mode)
665 {
666 	switch (mode) {
667 	case REDIR_INGRESS:
668 		return "ingress";
669 	case REDIR_EGRESS:
670 		return "egress";
671 	default:
672 		return "unknown";
673 	}
674 }
675 
redir_to_connected(int family,int sotype,int sock_mapfd,int verd_mapfd,enum redir_mode mode)676 static void redir_to_connected(int family, int sotype, int sock_mapfd,
677 			       int verd_mapfd, enum redir_mode mode)
678 {
679 	const char *log_prefix = redir_mode_str(mode);
680 	int c0, c1, p0, p1;
681 	unsigned int pass;
682 	int err, n;
683 	u32 key;
684 	char b;
685 
686 	zero_verdict_count(verd_mapfd);
687 
688 	err = create_socket_pairs(family, sotype | SOCK_NONBLOCK, &c0, &c1,
689 				  &p0, &p1);
690 	if (err)
691 		return;
692 
693 	err = add_to_sockmap(sock_mapfd, p0, p1);
694 	if (err)
695 		goto close;
696 
697 	n = write(mode == REDIR_INGRESS ? c1 : p1, "a", 1);
698 	if (n < 0)
699 		FAIL_ERRNO("%s: write", log_prefix);
700 	if (n == 0)
701 		FAIL("%s: incomplete write", log_prefix);
702 	if (n < 1)
703 		goto close;
704 
705 	key = SK_PASS;
706 	err = xbpf_map_lookup_elem(verd_mapfd, &key, &pass);
707 	if (err)
708 		goto close;
709 	if (pass != 1)
710 		FAIL("%s: want pass count 1, have %d", log_prefix, pass);
711 	n = recv_timeout(c0, &b, 1, 0, IO_TIMEOUT_SEC);
712 	if (n < 0)
713 		FAIL_ERRNO("%s: recv_timeout", log_prefix);
714 	if (n == 0)
715 		FAIL("%s: incomplete recv", log_prefix);
716 
717 close:
718 	xclose(p1);
719 	xclose(c1);
720 	xclose(p0);
721 	xclose(c0);
722 }
723 
test_skb_redir_to_connected(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)724 static void test_skb_redir_to_connected(struct test_sockmap_listen *skel,
725 					struct bpf_map *inner_map, int family,
726 					int sotype)
727 {
728 	int verdict = bpf_program__fd(skel->progs.prog_stream_verdict);
729 	int parser = bpf_program__fd(skel->progs.prog_stream_parser);
730 	int verdict_map = bpf_map__fd(skel->maps.verdict_map);
731 	int sock_map = bpf_map__fd(inner_map);
732 	int err;
733 
734 	err = xbpf_prog_attach(parser, sock_map, BPF_SK_SKB_STREAM_PARSER, 0);
735 	if (err)
736 		return;
737 	err = xbpf_prog_attach(verdict, sock_map, BPF_SK_SKB_STREAM_VERDICT, 0);
738 	if (err)
739 		goto detach;
740 
741 	redir_to_connected(family, sotype, sock_map, verdict_map,
742 			   REDIR_INGRESS);
743 
744 	xbpf_prog_detach2(verdict, sock_map, BPF_SK_SKB_STREAM_VERDICT);
745 detach:
746 	xbpf_prog_detach2(parser, sock_map, BPF_SK_SKB_STREAM_PARSER);
747 }
748 
test_msg_redir_to_connected(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)749 static void test_msg_redir_to_connected(struct test_sockmap_listen *skel,
750 					struct bpf_map *inner_map, int family,
751 					int sotype)
752 {
753 	int verdict = bpf_program__fd(skel->progs.prog_msg_verdict);
754 	int verdict_map = bpf_map__fd(skel->maps.verdict_map);
755 	int sock_map = bpf_map__fd(inner_map);
756 	int err;
757 
758 	err = xbpf_prog_attach(verdict, sock_map, BPF_SK_MSG_VERDICT, 0);
759 	if (err)
760 		return;
761 
762 	redir_to_connected(family, sotype, sock_map, verdict_map, REDIR_EGRESS);
763 
764 	xbpf_prog_detach2(verdict, sock_map, BPF_SK_MSG_VERDICT);
765 }
766 
test_msg_redir_to_connected_with_link(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)767 static void test_msg_redir_to_connected_with_link(struct test_sockmap_listen *skel,
768 						  struct bpf_map *inner_map, int family,
769 						  int sotype)
770 {
771 	int prog_msg_verdict = bpf_program__fd(skel->progs.prog_msg_verdict);
772 	int verdict_map = bpf_map__fd(skel->maps.verdict_map);
773 	int sock_map = bpf_map__fd(inner_map);
774 	int link_fd;
775 
776 	link_fd = bpf_link_create(prog_msg_verdict, sock_map, BPF_SK_MSG_VERDICT, NULL);
777 	if (!ASSERT_GE(link_fd, 0, "bpf_link_create"))
778 		return;
779 
780 	redir_to_connected(family, sotype, sock_map, verdict_map, REDIR_EGRESS);
781 
782 	close(link_fd);
783 }
784 
redir_to_listening(int family,int sotype,int sock_mapfd,int verd_mapfd,enum redir_mode mode)785 static void redir_to_listening(int family, int sotype, int sock_mapfd,
786 			       int verd_mapfd, enum redir_mode mode)
787 {
788 	const char *log_prefix = redir_mode_str(mode);
789 	struct sockaddr_storage addr;
790 	int s, c, p, err, n;
791 	unsigned int drop;
792 	socklen_t len;
793 	u32 key;
794 
795 	zero_verdict_count(verd_mapfd);
796 
797 	s = socket_loopback(family, sotype | SOCK_NONBLOCK);
798 	if (s < 0)
799 		return;
800 
801 	len = sizeof(addr);
802 	err = xgetsockname(s, sockaddr(&addr), &len);
803 	if (err)
804 		goto close_srv;
805 
806 	c = xsocket(family, sotype, 0);
807 	if (c < 0)
808 		goto close_srv;
809 	err = xconnect(c, sockaddr(&addr), len);
810 	if (err)
811 		goto close_cli;
812 
813 	p = xaccept_nonblock(s, NULL, NULL);
814 	if (p < 0)
815 		goto close_cli;
816 
817 	err = add_to_sockmap(sock_mapfd, s, p);
818 	if (err)
819 		goto close_peer;
820 
821 	n = write(mode == REDIR_INGRESS ? c : p, "a", 1);
822 	if (n < 0 && errno != EACCES)
823 		FAIL_ERRNO("%s: write", log_prefix);
824 	if (n == 0)
825 		FAIL("%s: incomplete write", log_prefix);
826 	if (n < 1)
827 		goto close_peer;
828 
829 	key = SK_DROP;
830 	err = xbpf_map_lookup_elem(verd_mapfd, &key, &drop);
831 	if (err)
832 		goto close_peer;
833 	if (drop != 1)
834 		FAIL("%s: want drop count 1, have %d", log_prefix, drop);
835 
836 close_peer:
837 	xclose(p);
838 close_cli:
839 	xclose(c);
840 close_srv:
841 	xclose(s);
842 }
843 
test_skb_redir_to_listening(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)844 static void test_skb_redir_to_listening(struct test_sockmap_listen *skel,
845 					struct bpf_map *inner_map, int family,
846 					int sotype)
847 {
848 	int verdict = bpf_program__fd(skel->progs.prog_stream_verdict);
849 	int parser = bpf_program__fd(skel->progs.prog_stream_parser);
850 	int verdict_map = bpf_map__fd(skel->maps.verdict_map);
851 	int sock_map = bpf_map__fd(inner_map);
852 	int err;
853 
854 	err = xbpf_prog_attach(parser, sock_map, BPF_SK_SKB_STREAM_PARSER, 0);
855 	if (err)
856 		return;
857 	err = xbpf_prog_attach(verdict, sock_map, BPF_SK_SKB_STREAM_VERDICT, 0);
858 	if (err)
859 		goto detach;
860 
861 	redir_to_listening(family, sotype, sock_map, verdict_map,
862 			   REDIR_INGRESS);
863 
864 	xbpf_prog_detach2(verdict, sock_map, BPF_SK_SKB_STREAM_VERDICT);
865 detach:
866 	xbpf_prog_detach2(parser, sock_map, BPF_SK_SKB_STREAM_PARSER);
867 }
868 
test_msg_redir_to_listening(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)869 static void test_msg_redir_to_listening(struct test_sockmap_listen *skel,
870 					struct bpf_map *inner_map, int family,
871 					int sotype)
872 {
873 	int verdict = bpf_program__fd(skel->progs.prog_msg_verdict);
874 	int verdict_map = bpf_map__fd(skel->maps.verdict_map);
875 	int sock_map = bpf_map__fd(inner_map);
876 	int err;
877 
878 	err = xbpf_prog_attach(verdict, sock_map, BPF_SK_MSG_VERDICT, 0);
879 	if (err)
880 		return;
881 
882 	redir_to_listening(family, sotype, sock_map, verdict_map, REDIR_EGRESS);
883 
884 	xbpf_prog_detach2(verdict, sock_map, BPF_SK_MSG_VERDICT);
885 }
886 
test_msg_redir_to_listening_with_link(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)887 static void test_msg_redir_to_listening_with_link(struct test_sockmap_listen *skel,
888 						  struct bpf_map *inner_map, int family,
889 						  int sotype)
890 {
891 	struct bpf_program *verdict = skel->progs.prog_msg_verdict;
892 	int verdict_map = bpf_map__fd(skel->maps.verdict_map);
893 	int sock_map = bpf_map__fd(inner_map);
894 	struct bpf_link *link;
895 
896 	link = bpf_program__attach_sockmap(verdict, sock_map);
897 	if (!ASSERT_OK_PTR(link, "bpf_program__attach_sockmap"))
898 		return;
899 
900 	redir_to_listening(family, sotype, sock_map, verdict_map, REDIR_EGRESS);
901 
902 	bpf_link__detach(link);
903 }
904 
redir_partial(int family,int sotype,int sock_map,int parser_map)905 static void redir_partial(int family, int sotype, int sock_map, int parser_map)
906 {
907 	int c0 = -1, c1 = -1, p0 = -1, p1 = -1;
908 	int err, n, key, value;
909 	char buf[] = "abc";
910 
911 	key = 0;
912 	value = sizeof(buf) - 1;
913 	err = xbpf_map_update_elem(parser_map, &key, &value, 0);
914 	if (err)
915 		return;
916 
917 	err = create_socket_pairs(family, sotype | SOCK_NONBLOCK, &c0, &c1,
918 				  &p0, &p1);
919 	if (err)
920 		goto clean_parser_map;
921 
922 	err = add_to_sockmap(sock_map, p0, p1);
923 	if (err)
924 		goto close;
925 
926 	n = xsend(c1, buf, sizeof(buf), 0);
927 	if (n == -1)
928 		goto close;
929 	if (n < sizeof(buf))
930 		FAIL("incomplete write");
931 
932 	n = xrecv_nonblock(c0, buf, sizeof(buf), 0);
933 	if (n != sizeof(buf) - 1)
934 		FAIL("expect %zu, received %d", sizeof(buf) - 1, n);
935 
936 close:
937 	xclose(c0);
938 	xclose(p0);
939 	xclose(c1);
940 	xclose(p1);
941 
942 clean_parser_map:
943 	key = 0;
944 	value = 0;
945 	xbpf_map_update_elem(parser_map, &key, &value, 0);
946 }
947 
test_skb_redir_partial(struct test_sockmap_listen * skel,struct bpf_map * inner_map,int family,int sotype)948 static void test_skb_redir_partial(struct test_sockmap_listen *skel,
949 				   struct bpf_map *inner_map, int family,
950 				   int sotype)
951 {
952 	int verdict = bpf_program__fd(skel->progs.prog_stream_verdict);
953 	int parser = bpf_program__fd(skel->progs.prog_stream_parser);
954 	int parser_map = bpf_map__fd(skel->maps.parser_map);
955 	int sock_map = bpf_map__fd(inner_map);
956 	int err;
957 
958 	err = xbpf_prog_attach(parser, sock_map, BPF_SK_SKB_STREAM_PARSER, 0);
959 	if (err)
960 		return;
961 
962 	err = xbpf_prog_attach(verdict, sock_map, BPF_SK_SKB_STREAM_VERDICT, 0);
963 	if (err)
964 		goto detach;
965 
966 	redir_partial(family, sotype, sock_map, parser_map);
967 
968 	xbpf_prog_detach2(verdict, sock_map, BPF_SK_SKB_STREAM_VERDICT);
969 detach:
970 	xbpf_prog_detach2(parser, sock_map, BPF_SK_SKB_STREAM_PARSER);
971 }
972 
test_reuseport_select_listening(int family,int sotype,int sock_map,int verd_map,int reuseport_prog)973 static void test_reuseport_select_listening(int family, int sotype,
974 					    int sock_map, int verd_map,
975 					    int reuseport_prog)
976 {
977 	struct sockaddr_storage addr;
978 	unsigned int pass;
979 	int s, c, err;
980 	socklen_t len;
981 	u64 value;
982 	u32 key;
983 
984 	zero_verdict_count(verd_map);
985 
986 	s = socket_loopback_reuseport(family, sotype | SOCK_NONBLOCK,
987 				      reuseport_prog);
988 	if (s < 0)
989 		return;
990 
991 	len = sizeof(addr);
992 	err = xgetsockname(s, sockaddr(&addr), &len);
993 	if (err)
994 		goto close_srv;
995 
996 	key = 0;
997 	value = s;
998 	err = xbpf_map_update_elem(sock_map, &key, &value, BPF_NOEXIST);
999 	if (err)
1000 		goto close_srv;
1001 
1002 	c = xsocket(family, sotype, 0);
1003 	if (c < 0)
1004 		goto close_srv;
1005 	err = xconnect(c, sockaddr(&addr), len);
1006 	if (err)
1007 		goto close_cli;
1008 
1009 	if (sotype == SOCK_STREAM) {
1010 		int p;
1011 
1012 		p = xaccept_nonblock(s, NULL, NULL);
1013 		if (p < 0)
1014 			goto close_cli;
1015 		xclose(p);
1016 	} else {
1017 		char b = 'a';
1018 		ssize_t n;
1019 
1020 		n = xsend(c, &b, sizeof(b), 0);
1021 		if (n == -1)
1022 			goto close_cli;
1023 
1024 		n = xrecv_nonblock(s, &b, sizeof(b), 0);
1025 		if (n == -1)
1026 			goto close_cli;
1027 	}
1028 
1029 	key = SK_PASS;
1030 	err = xbpf_map_lookup_elem(verd_map, &key, &pass);
1031 	if (err)
1032 		goto close_cli;
1033 	if (pass != 1)
1034 		FAIL("want pass count 1, have %d", pass);
1035 
1036 close_cli:
1037 	xclose(c);
1038 close_srv:
1039 	xclose(s);
1040 }
1041 
test_reuseport_select_connected(int family,int sotype,int sock_map,int verd_map,int reuseport_prog)1042 static void test_reuseport_select_connected(int family, int sotype,
1043 					    int sock_map, int verd_map,
1044 					    int reuseport_prog)
1045 {
1046 	struct sockaddr_storage addr;
1047 	int s, c0, c1, p0, err;
1048 	unsigned int drop;
1049 	socklen_t len;
1050 	u64 value;
1051 	u32 key;
1052 
1053 	zero_verdict_count(verd_map);
1054 
1055 	s = socket_loopback_reuseport(family, sotype, reuseport_prog);
1056 	if (s < 0)
1057 		return;
1058 
1059 	/* Populate sock_map[0] to avoid ENOENT on first connection */
1060 	key = 0;
1061 	value = s;
1062 	err = xbpf_map_update_elem(sock_map, &key, &value, BPF_NOEXIST);
1063 	if (err)
1064 		goto close_srv;
1065 
1066 	len = sizeof(addr);
1067 	err = xgetsockname(s, sockaddr(&addr), &len);
1068 	if (err)
1069 		goto close_srv;
1070 
1071 	c0 = xsocket(family, sotype, 0);
1072 	if (c0 < 0)
1073 		goto close_srv;
1074 
1075 	err = xconnect(c0, sockaddr(&addr), len);
1076 	if (err)
1077 		goto close_cli0;
1078 
1079 	if (sotype == SOCK_STREAM) {
1080 		p0 = xaccept_nonblock(s, NULL, NULL);
1081 		if (p0 < 0)
1082 			goto close_cli0;
1083 	} else {
1084 		p0 = xsocket(family, sotype, 0);
1085 		if (p0 < 0)
1086 			goto close_cli0;
1087 
1088 		len = sizeof(addr);
1089 		err = xgetsockname(c0, sockaddr(&addr), &len);
1090 		if (err)
1091 			goto close_cli0;
1092 
1093 		err = xconnect(p0, sockaddr(&addr), len);
1094 		if (err)
1095 			goto close_cli0;
1096 	}
1097 
1098 	/* Update sock_map[0] to redirect to a connected socket */
1099 	key = 0;
1100 	value = p0;
1101 	err = xbpf_map_update_elem(sock_map, &key, &value, BPF_EXIST);
1102 	if (err)
1103 		goto close_peer0;
1104 
1105 	c1 = xsocket(family, sotype, 0);
1106 	if (c1 < 0)
1107 		goto close_peer0;
1108 
1109 	len = sizeof(addr);
1110 	err = xgetsockname(s, sockaddr(&addr), &len);
1111 	if (err)
1112 		goto close_srv;
1113 
1114 	errno = 0;
1115 	err = connect(c1, sockaddr(&addr), len);
1116 	if (sotype == SOCK_DGRAM) {
1117 		char b = 'a';
1118 		ssize_t n;
1119 
1120 		n = xsend(c1, &b, sizeof(b), 0);
1121 		if (n == -1)
1122 			goto close_cli1;
1123 
1124 		n = recv_timeout(c1, &b, sizeof(b), 0, IO_TIMEOUT_SEC);
1125 		err = n == -1;
1126 	}
1127 	if (!err || errno != ECONNREFUSED)
1128 		FAIL_ERRNO("connect: expected ECONNREFUSED");
1129 
1130 	key = SK_DROP;
1131 	err = xbpf_map_lookup_elem(verd_map, &key, &drop);
1132 	if (err)
1133 		goto close_cli1;
1134 	if (drop != 1)
1135 		FAIL("want drop count 1, have %d", drop);
1136 
1137 close_cli1:
1138 	xclose(c1);
1139 close_peer0:
1140 	xclose(p0);
1141 close_cli0:
1142 	xclose(c0);
1143 close_srv:
1144 	xclose(s);
1145 }
1146 
1147 /* Check that redirecting across reuseport groups is not allowed. */
test_reuseport_mixed_groups(int family,int sotype,int sock_map,int verd_map,int reuseport_prog)1148 static void test_reuseport_mixed_groups(int family, int sotype, int sock_map,
1149 					int verd_map, int reuseport_prog)
1150 {
1151 	struct sockaddr_storage addr;
1152 	int s1, s2, c, err;
1153 	unsigned int drop;
1154 	socklen_t len;
1155 	u32 key;
1156 
1157 	zero_verdict_count(verd_map);
1158 
1159 	/* Create two listeners, each in its own reuseport group */
1160 	s1 = socket_loopback_reuseport(family, sotype, reuseport_prog);
1161 	if (s1 < 0)
1162 		return;
1163 
1164 	s2 = socket_loopback_reuseport(family, sotype, reuseport_prog);
1165 	if (s2 < 0)
1166 		goto close_srv1;
1167 
1168 	err = add_to_sockmap(sock_map, s1, s2);
1169 	if (err)
1170 		goto close_srv2;
1171 
1172 	/* Connect to s2, reuseport BPF selects s1 via sock_map[0] */
1173 	len = sizeof(addr);
1174 	err = xgetsockname(s2, sockaddr(&addr), &len);
1175 	if (err)
1176 		goto close_srv2;
1177 
1178 	c = xsocket(family, sotype, 0);
1179 	if (c < 0)
1180 		goto close_srv2;
1181 
1182 	err = connect(c, sockaddr(&addr), len);
1183 	if (sotype == SOCK_DGRAM) {
1184 		char b = 'a';
1185 		ssize_t n;
1186 
1187 		n = xsend(c, &b, sizeof(b), 0);
1188 		if (n == -1)
1189 			goto close_cli;
1190 
1191 		n = recv_timeout(c, &b, sizeof(b), 0, IO_TIMEOUT_SEC);
1192 		err = n == -1;
1193 	}
1194 	if (!err || errno != ECONNREFUSED) {
1195 		FAIL_ERRNO("connect: expected ECONNREFUSED");
1196 		goto close_cli;
1197 	}
1198 
1199 	/* Expect drop, can't redirect outside of reuseport group */
1200 	key = SK_DROP;
1201 	err = xbpf_map_lookup_elem(verd_map, &key, &drop);
1202 	if (err)
1203 		goto close_cli;
1204 	if (drop != 1)
1205 		FAIL("want drop count 1, have %d", drop);
1206 
1207 close_cli:
1208 	xclose(c);
1209 close_srv2:
1210 	xclose(s2);
1211 close_srv1:
1212 	xclose(s1);
1213 }
1214 
1215 #define TEST(fn, ...)                                                          \
1216 	{                                                                      \
1217 		fn, #fn, __VA_ARGS__                                           \
1218 	}
1219 
test_ops_cleanup(const struct bpf_map * map)1220 static void test_ops_cleanup(const struct bpf_map *map)
1221 {
1222 	int err, mapfd;
1223 	u32 key;
1224 
1225 	mapfd = bpf_map__fd(map);
1226 
1227 	for (key = 0; key < bpf_map__max_entries(map); key++) {
1228 		err = bpf_map_delete_elem(mapfd, &key);
1229 		if (err && errno != EINVAL && errno != ENOENT)
1230 			FAIL_ERRNO("map_delete: expected EINVAL/ENOENT");
1231 	}
1232 }
1233 
family_str(sa_family_t family)1234 static const char *family_str(sa_family_t family)
1235 {
1236 	switch (family) {
1237 	case AF_INET:
1238 		return "IPv4";
1239 	case AF_INET6:
1240 		return "IPv6";
1241 	case AF_UNIX:
1242 		return "Unix";
1243 	case AF_VSOCK:
1244 		return "VSOCK";
1245 	default:
1246 		return "unknown";
1247 	}
1248 }
1249 
map_type_str(const struct bpf_map * map)1250 static const char *map_type_str(const struct bpf_map *map)
1251 {
1252 	int type;
1253 
1254 	if (!map)
1255 		return "invalid";
1256 	type = bpf_map__type(map);
1257 
1258 	switch (type) {
1259 	case BPF_MAP_TYPE_SOCKMAP:
1260 		return "sockmap";
1261 	case BPF_MAP_TYPE_SOCKHASH:
1262 		return "sockhash";
1263 	default:
1264 		return "unknown";
1265 	}
1266 }
1267 
sotype_str(int sotype)1268 static const char *sotype_str(int sotype)
1269 {
1270 	switch (sotype) {
1271 	case SOCK_DGRAM:
1272 		return "UDP";
1273 	case SOCK_STREAM:
1274 		return "TCP";
1275 	default:
1276 		return "unknown";
1277 	}
1278 }
1279 
test_ops(struct test_sockmap_listen * skel,struct bpf_map * map,int family,int sotype)1280 static void test_ops(struct test_sockmap_listen *skel, struct bpf_map *map,
1281 		     int family, int sotype)
1282 {
1283 	const struct op_test {
1284 		void (*fn)(struct test_sockmap_listen *skel,
1285 			   int family, int sotype, int mapfd);
1286 		const char *name;
1287 		int sotype;
1288 	} tests[] = {
1289 		/* insert */
1290 		TEST(test_insert_invalid),
1291 		TEST(test_insert_opened),
1292 		TEST(test_insert_bound, SOCK_STREAM),
1293 		TEST(test_insert),
1294 		/* delete */
1295 		TEST(test_delete_after_insert),
1296 		TEST(test_delete_after_close),
1297 		/* lookup */
1298 		TEST(test_lookup_after_insert),
1299 		TEST(test_lookup_after_delete),
1300 		TEST(test_lookup_32_bit_value),
1301 		/* update */
1302 		TEST(test_update_existing),
1303 		/* races with insert/delete */
1304 		TEST(test_destroy_orphan_child, SOCK_STREAM),
1305 		TEST(test_syn_recv_insert_delete, SOCK_STREAM),
1306 		TEST(test_race_insert_listen, SOCK_STREAM),
1307 		/* child clone */
1308 		TEST(test_clone_after_delete, SOCK_STREAM),
1309 		TEST(test_accept_after_delete, SOCK_STREAM),
1310 		TEST(test_accept_before_delete, SOCK_STREAM),
1311 	};
1312 	const char *family_name, *map_name, *sotype_name;
1313 	const struct op_test *t;
1314 	char s[MAX_TEST_NAME];
1315 	int map_fd;
1316 
1317 	family_name = family_str(family);
1318 	map_name = map_type_str(map);
1319 	sotype_name = sotype_str(sotype);
1320 	map_fd = bpf_map__fd(map);
1321 
1322 	for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
1323 		snprintf(s, sizeof(s), "%s %s %s %s", map_name, family_name,
1324 			 sotype_name, t->name);
1325 
1326 		if (t->sotype != 0 && t->sotype != sotype)
1327 			continue;
1328 
1329 		if (!test__start_subtest(s))
1330 			continue;
1331 
1332 		t->fn(skel, family, sotype, map_fd);
1333 		test_ops_cleanup(map);
1334 	}
1335 }
1336 
test_redir(struct test_sockmap_listen * skel,struct bpf_map * map,int family,int sotype)1337 static void test_redir(struct test_sockmap_listen *skel, struct bpf_map *map,
1338 		       int family, int sotype)
1339 {
1340 	const struct redir_test {
1341 		void (*fn)(struct test_sockmap_listen *skel,
1342 			   struct bpf_map *map, int family, int sotype);
1343 		const char *name;
1344 	} tests[] = {
1345 		TEST(test_skb_redir_to_connected),
1346 		TEST(test_skb_redir_to_listening),
1347 		TEST(test_skb_redir_partial),
1348 		TEST(test_msg_redir_to_connected),
1349 		TEST(test_msg_redir_to_connected_with_link),
1350 		TEST(test_msg_redir_to_listening),
1351 		TEST(test_msg_redir_to_listening_with_link),
1352 	};
1353 	const char *family_name, *map_name;
1354 	const struct redir_test *t;
1355 	char s[MAX_TEST_NAME];
1356 
1357 	family_name = family_str(family);
1358 	map_name = map_type_str(map);
1359 
1360 	for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
1361 		snprintf(s, sizeof(s), "%s %s %s", map_name, family_name,
1362 			 t->name);
1363 
1364 		if (!test__start_subtest(s))
1365 			continue;
1366 
1367 		t->fn(skel, map, family, sotype);
1368 	}
1369 }
1370 
test_reuseport(struct test_sockmap_listen * skel,struct bpf_map * map,int family,int sotype)1371 static void test_reuseport(struct test_sockmap_listen *skel,
1372 			   struct bpf_map *map, int family, int sotype)
1373 {
1374 	const struct reuseport_test {
1375 		void (*fn)(int family, int sotype, int socket_map,
1376 			   int verdict_map, int reuseport_prog);
1377 		const char *name;
1378 		int sotype;
1379 	} tests[] = {
1380 		TEST(test_reuseport_select_listening),
1381 		TEST(test_reuseport_select_connected),
1382 		TEST(test_reuseport_mixed_groups),
1383 	};
1384 	int socket_map, verdict_map, reuseport_prog;
1385 	const char *family_name, *map_name, *sotype_name;
1386 	const struct reuseport_test *t;
1387 	char s[MAX_TEST_NAME];
1388 
1389 	family_name = family_str(family);
1390 	map_name = map_type_str(map);
1391 	sotype_name = sotype_str(sotype);
1392 
1393 	socket_map = bpf_map__fd(map);
1394 	verdict_map = bpf_map__fd(skel->maps.verdict_map);
1395 	reuseport_prog = bpf_program__fd(skel->progs.prog_reuseport);
1396 
1397 	for (t = tests; t < tests + ARRAY_SIZE(tests); t++) {
1398 		snprintf(s, sizeof(s), "%s %s %s %s", map_name, family_name,
1399 			 sotype_name, t->name);
1400 
1401 		if (t->sotype != 0 && t->sotype != sotype)
1402 			continue;
1403 
1404 		if (!test__start_subtest(s))
1405 			continue;
1406 
1407 		t->fn(family, sotype, socket_map, verdict_map, reuseport_prog);
1408 	}
1409 }
1410 
run_tests(struct test_sockmap_listen * skel,struct bpf_map * map,int family)1411 static void run_tests(struct test_sockmap_listen *skel, struct bpf_map *map,
1412 		      int family)
1413 {
1414 	test_ops(skel, map, family, SOCK_STREAM);
1415 	test_ops(skel, map, family, SOCK_DGRAM);
1416 	test_redir(skel, map, family, SOCK_STREAM);
1417 	test_reuseport(skel, map, family, SOCK_STREAM);
1418 	test_reuseport(skel, map, family, SOCK_DGRAM);
1419 }
1420 
serial_test_sockmap_listen(void)1421 void serial_test_sockmap_listen(void)
1422 {
1423 	struct test_sockmap_listen *skel;
1424 
1425 	skel = test_sockmap_listen__open_and_load();
1426 	if (!skel) {
1427 		FAIL("skeleton open/load failed");
1428 		return;
1429 	}
1430 
1431 	skel->bss->test_sockmap = true;
1432 	run_tests(skel, skel->maps.sock_map, AF_INET);
1433 	run_tests(skel, skel->maps.sock_map, AF_INET6);
1434 
1435 	skel->bss->test_sockmap = false;
1436 	run_tests(skel, skel->maps.sock_hash, AF_INET);
1437 	run_tests(skel, skel->maps.sock_hash, AF_INET6);
1438 
1439 	test_sockmap_listen__destroy(skel);
1440 }
1441