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