cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

reuseport_bpf.c (17583B)


      1/*
      2 * Test functionality of BPF filters for SO_REUSEPORT.  The tests below will use
      3 * a BPF program (both classic and extended) to read the first word from an
      4 * incoming packet (expected to be in network byte-order), calculate a modulus
      5 * of that number, and then dispatch the packet to the Nth socket using the
      6 * result.  These tests are run for each supported address family and protocol.
      7 * Additionally, a few edge cases in the implementation are tested.
      8 */
      9
     10#include <errno.h>
     11#include <error.h>
     12#include <fcntl.h>
     13#include <linux/bpf.h>
     14#include <linux/filter.h>
     15#include <linux/unistd.h>
     16#include <netinet/in.h>
     17#include <netinet/tcp.h>
     18#include <stdio.h>
     19#include <stdlib.h>
     20#include <string.h>
     21#include <sys/epoll.h>
     22#include <sys/types.h>
     23#include <sys/socket.h>
     24#include <sys/resource.h>
     25#include <unistd.h>
     26
     27#include "../kselftest.h"
     28
     29struct test_params {
     30	int recv_family;
     31	int send_family;
     32	int protocol;
     33	size_t recv_socks;
     34	uint16_t recv_port;
     35	uint16_t send_port_min;
     36};
     37
     38static size_t sockaddr_size(void)
     39{
     40	return sizeof(struct sockaddr_storage);
     41}
     42
     43static struct sockaddr *new_any_sockaddr(int family, uint16_t port)
     44{
     45	struct sockaddr_storage *addr;
     46	struct sockaddr_in *addr4;
     47	struct sockaddr_in6 *addr6;
     48
     49	addr = malloc(sizeof(struct sockaddr_storage));
     50	memset(addr, 0, sizeof(struct sockaddr_storage));
     51
     52	switch (family) {
     53	case AF_INET:
     54		addr4 = (struct sockaddr_in *)addr;
     55		addr4->sin_family = AF_INET;
     56		addr4->sin_addr.s_addr = htonl(INADDR_ANY);
     57		addr4->sin_port = htons(port);
     58		break;
     59	case AF_INET6:
     60		addr6 = (struct sockaddr_in6 *)addr;
     61		addr6->sin6_family = AF_INET6;
     62		addr6->sin6_addr = in6addr_any;
     63		addr6->sin6_port = htons(port);
     64		break;
     65	default:
     66		error(1, 0, "Unsupported family %d", family);
     67	}
     68	return (struct sockaddr *)addr;
     69}
     70
     71static struct sockaddr *new_loopback_sockaddr(int family, uint16_t port)
     72{
     73	struct sockaddr *addr = new_any_sockaddr(family, port);
     74	struct sockaddr_in *addr4;
     75	struct sockaddr_in6 *addr6;
     76
     77	switch (family) {
     78	case AF_INET:
     79		addr4 = (struct sockaddr_in *)addr;
     80		addr4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
     81		break;
     82	case AF_INET6:
     83		addr6 = (struct sockaddr_in6 *)addr;
     84		addr6->sin6_addr = in6addr_loopback;
     85		break;
     86	default:
     87		error(1, 0, "Unsupported family %d", family);
     88	}
     89	return addr;
     90}
     91
     92static void attach_ebpf(int fd, uint16_t mod)
     93{
     94	static char bpf_log_buf[65536];
     95	static const char bpf_license[] = "GPL";
     96
     97	int bpf_fd;
     98	const struct bpf_insn prog[] = {
     99		/* BPF_MOV64_REG(BPF_REG_6, BPF_REG_1) */
    100		{ BPF_ALU64 | BPF_MOV | BPF_X, BPF_REG_6, BPF_REG_1, 0, 0 },
    101		/* BPF_LD_ABS(BPF_W, 0) R0 = (uint32_t)skb[0] */
    102		{ BPF_LD | BPF_ABS | BPF_W, 0, 0, 0, 0 },
    103		/* BPF_ALU64_IMM(BPF_MOD, BPF_REG_0, mod) */
    104		{ BPF_ALU64 | BPF_MOD | BPF_K, BPF_REG_0, 0, 0, mod },
    105		/* BPF_EXIT_INSN() */
    106		{ BPF_JMP | BPF_EXIT, 0, 0, 0, 0 }
    107	};
    108	union bpf_attr attr;
    109
    110	memset(&attr, 0, sizeof(attr));
    111	attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
    112	attr.insn_cnt = ARRAY_SIZE(prog);
    113	attr.insns = (unsigned long) &prog;
    114	attr.license = (unsigned long) &bpf_license;
    115	attr.log_buf = (unsigned long) &bpf_log_buf;
    116	attr.log_size = sizeof(bpf_log_buf);
    117	attr.log_level = 1;
    118	attr.kern_version = 0;
    119
    120	bpf_fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
    121	if (bpf_fd < 0)
    122		error(1, errno, "ebpf error. log:\n%s\n", bpf_log_buf);
    123
    124	if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_REUSEPORT_EBPF, &bpf_fd,
    125			sizeof(bpf_fd)))
    126		error(1, errno, "failed to set SO_ATTACH_REUSEPORT_EBPF");
    127
    128	close(bpf_fd);
    129}
    130
    131static void attach_cbpf(int fd, uint16_t mod)
    132{
    133	struct sock_filter code[] = {
    134		/* A = (uint32_t)skb[0] */
    135		{ BPF_LD  | BPF_W | BPF_ABS, 0, 0, 0 },
    136		/* A = A % mod */
    137		{ BPF_ALU | BPF_MOD, 0, 0, mod },
    138		/* return A */
    139		{ BPF_RET | BPF_A, 0, 0, 0 },
    140	};
    141	struct sock_fprog p = {
    142		.len = ARRAY_SIZE(code),
    143		.filter = code,
    144	};
    145
    146	if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_REUSEPORT_CBPF, &p, sizeof(p)))
    147		error(1, errno, "failed to set SO_ATTACH_REUSEPORT_CBPF");
    148}
    149
    150static void build_recv_group(const struct test_params p, int fd[], uint16_t mod,
    151			     void (*attach_bpf)(int, uint16_t))
    152{
    153	struct sockaddr * const addr =
    154		new_any_sockaddr(p.recv_family, p.recv_port);
    155	int i, opt;
    156
    157	for (i = 0; i < p.recv_socks; ++i) {
    158		fd[i] = socket(p.recv_family, p.protocol, 0);
    159		if (fd[i] < 0)
    160			error(1, errno, "failed to create recv %d", i);
    161
    162		opt = 1;
    163		if (setsockopt(fd[i], SOL_SOCKET, SO_REUSEPORT, &opt,
    164			       sizeof(opt)))
    165			error(1, errno, "failed to set SO_REUSEPORT on %d", i);
    166
    167		if (i == 0)
    168			attach_bpf(fd[i], mod);
    169
    170		if (bind(fd[i], addr, sockaddr_size()))
    171			error(1, errno, "failed to bind recv socket %d", i);
    172
    173		if (p.protocol == SOCK_STREAM) {
    174			opt = 4;
    175			if (setsockopt(fd[i], SOL_TCP, TCP_FASTOPEN, &opt,
    176				       sizeof(opt)))
    177				error(1, errno,
    178				      "failed to set TCP_FASTOPEN on %d", i);
    179			if (listen(fd[i], p.recv_socks * 10))
    180				error(1, errno, "failed to listen on socket");
    181		}
    182	}
    183	free(addr);
    184}
    185
    186static void send_from(struct test_params p, uint16_t sport, char *buf,
    187		      size_t len)
    188{
    189	struct sockaddr * const saddr = new_any_sockaddr(p.send_family, sport);
    190	struct sockaddr * const daddr =
    191		new_loopback_sockaddr(p.send_family, p.recv_port);
    192	const int fd = socket(p.send_family, p.protocol, 0), one = 1;
    193
    194	if (fd < 0)
    195		error(1, errno, "failed to create send socket");
    196
    197	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)))
    198		error(1, errno, "failed to set reuseaddr");
    199
    200	if (bind(fd, saddr, sockaddr_size()))
    201		error(1, errno, "failed to bind send socket");
    202
    203	if (sendto(fd, buf, len, MSG_FASTOPEN, daddr, sockaddr_size()) < 0)
    204		error(1, errno, "failed to send message");
    205
    206	close(fd);
    207	free(saddr);
    208	free(daddr);
    209}
    210
    211static void test_recv_order(const struct test_params p, int fd[], int mod)
    212{
    213	char recv_buf[8], send_buf[8];
    214	struct msghdr msg;
    215	struct iovec recv_io = { recv_buf, 8 };
    216	struct epoll_event ev;
    217	int epfd, conn, i, sport, expected;
    218	uint32_t data, ndata;
    219
    220	epfd = epoll_create(1);
    221	if (epfd < 0)
    222		error(1, errno, "failed to create epoll");
    223	for (i = 0; i < p.recv_socks; ++i) {
    224		ev.events = EPOLLIN;
    225		ev.data.fd = fd[i];
    226		if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd[i], &ev))
    227			error(1, errno, "failed to register sock %d epoll", i);
    228	}
    229
    230	memset(&msg, 0, sizeof(msg));
    231	msg.msg_iov = &recv_io;
    232	msg.msg_iovlen = 1;
    233
    234	for (data = 0; data < p.recv_socks * 2; ++data) {
    235		sport = p.send_port_min + data;
    236		ndata = htonl(data);
    237		memcpy(send_buf, &ndata, sizeof(ndata));
    238		send_from(p, sport, send_buf, sizeof(ndata));
    239
    240		i = epoll_wait(epfd, &ev, 1, -1);
    241		if (i < 0)
    242			error(1, errno, "epoll wait failed");
    243
    244		if (p.protocol == SOCK_STREAM) {
    245			conn = accept(ev.data.fd, NULL, NULL);
    246			if (conn < 0)
    247				error(1, errno, "error accepting");
    248			i = recvmsg(conn, &msg, 0);
    249			close(conn);
    250		} else {
    251			i = recvmsg(ev.data.fd, &msg, 0);
    252		}
    253		if (i < 0)
    254			error(1, errno, "recvmsg error");
    255		if (i != sizeof(ndata))
    256			error(1, 0, "expected size %zd got %d",
    257			      sizeof(ndata), i);
    258
    259		for (i = 0; i < p.recv_socks; ++i)
    260			if (ev.data.fd == fd[i])
    261				break;
    262		memcpy(&ndata, recv_buf, sizeof(ndata));
    263		fprintf(stderr, "Socket %d: %d\n", i, ntohl(ndata));
    264
    265		expected = (sport % mod);
    266		if (i != expected)
    267			error(1, 0, "expected socket %d", expected);
    268	}
    269}
    270
    271static void test_reuseport_ebpf(struct test_params p)
    272{
    273	int i, fd[p.recv_socks];
    274
    275	fprintf(stderr, "Testing EBPF mod %zd...\n", p.recv_socks);
    276	build_recv_group(p, fd, p.recv_socks, attach_ebpf);
    277	test_recv_order(p, fd, p.recv_socks);
    278
    279	p.send_port_min += p.recv_socks * 2;
    280	fprintf(stderr, "Reprograming, testing mod %zd...\n", p.recv_socks / 2);
    281	attach_ebpf(fd[0], p.recv_socks / 2);
    282	test_recv_order(p, fd, p.recv_socks / 2);
    283
    284	for (i = 0; i < p.recv_socks; ++i)
    285		close(fd[i]);
    286}
    287
    288static void test_reuseport_cbpf(struct test_params p)
    289{
    290	int i, fd[p.recv_socks];
    291
    292	fprintf(stderr, "Testing CBPF mod %zd...\n", p.recv_socks);
    293	build_recv_group(p, fd, p.recv_socks, attach_cbpf);
    294	test_recv_order(p, fd, p.recv_socks);
    295
    296	p.send_port_min += p.recv_socks * 2;
    297	fprintf(stderr, "Reprograming, testing mod %zd...\n", p.recv_socks / 2);
    298	attach_cbpf(fd[0], p.recv_socks / 2);
    299	test_recv_order(p, fd, p.recv_socks / 2);
    300
    301	for (i = 0; i < p.recv_socks; ++i)
    302		close(fd[i]);
    303}
    304
    305static void test_extra_filter(const struct test_params p)
    306{
    307	struct sockaddr * const addr =
    308		new_any_sockaddr(p.recv_family, p.recv_port);
    309	int fd1, fd2, opt;
    310
    311	fprintf(stderr, "Testing too many filters...\n");
    312	fd1 = socket(p.recv_family, p.protocol, 0);
    313	if (fd1 < 0)
    314		error(1, errno, "failed to create socket 1");
    315	fd2 = socket(p.recv_family, p.protocol, 0);
    316	if (fd2 < 0)
    317		error(1, errno, "failed to create socket 2");
    318
    319	opt = 1;
    320	if (setsockopt(fd1, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)))
    321		error(1, errno, "failed to set SO_REUSEPORT on socket 1");
    322	if (setsockopt(fd2, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)))
    323		error(1, errno, "failed to set SO_REUSEPORT on socket 2");
    324
    325	attach_ebpf(fd1, 10);
    326	attach_ebpf(fd2, 10);
    327
    328	if (bind(fd1, addr, sockaddr_size()))
    329		error(1, errno, "failed to bind recv socket 1");
    330
    331	if (!bind(fd2, addr, sockaddr_size()) && errno != EADDRINUSE)
    332		error(1, errno, "bind socket 2 should fail with EADDRINUSE");
    333
    334	free(addr);
    335}
    336
    337static void test_filter_no_reuseport(const struct test_params p)
    338{
    339	struct sockaddr * const addr =
    340		new_any_sockaddr(p.recv_family, p.recv_port);
    341	const char bpf_license[] = "GPL";
    342	struct bpf_insn ecode[] = {
    343		{ BPF_ALU64 | BPF_MOV | BPF_K, BPF_REG_0, 0, 0, 10 },
    344		{ BPF_JMP | BPF_EXIT, 0, 0, 0, 0 }
    345	};
    346	struct sock_filter ccode[] = {{ BPF_RET | BPF_A, 0, 0, 0 }};
    347	union bpf_attr eprog;
    348	struct sock_fprog cprog;
    349	int fd, bpf_fd;
    350
    351	fprintf(stderr, "Testing filters on non-SO_REUSEPORT socket...\n");
    352
    353	memset(&eprog, 0, sizeof(eprog));
    354	eprog.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
    355	eprog.insn_cnt = ARRAY_SIZE(ecode);
    356	eprog.insns = (unsigned long) &ecode;
    357	eprog.license = (unsigned long) &bpf_license;
    358	eprog.kern_version = 0;
    359
    360	memset(&cprog, 0, sizeof(cprog));
    361	cprog.len = ARRAY_SIZE(ccode);
    362	cprog.filter = ccode;
    363
    364
    365	bpf_fd = syscall(__NR_bpf, BPF_PROG_LOAD, &eprog, sizeof(eprog));
    366	if (bpf_fd < 0)
    367		error(1, errno, "ebpf error");
    368	fd = socket(p.recv_family, p.protocol, 0);
    369	if (fd < 0)
    370		error(1, errno, "failed to create socket 1");
    371
    372	if (bind(fd, addr, sockaddr_size()))
    373		error(1, errno, "failed to bind recv socket 1");
    374
    375	errno = 0;
    376	if (!setsockopt(fd, SOL_SOCKET, SO_ATTACH_REUSEPORT_EBPF, &bpf_fd,
    377			sizeof(bpf_fd)) || errno != EINVAL)
    378		error(1, errno, "setsockopt should have returned EINVAL");
    379
    380	errno = 0;
    381	if (!setsockopt(fd, SOL_SOCKET, SO_ATTACH_REUSEPORT_CBPF, &cprog,
    382		       sizeof(cprog)) || errno != EINVAL)
    383		error(1, errno, "setsockopt should have returned EINVAL");
    384
    385	free(addr);
    386}
    387
    388static void test_filter_without_bind(void)
    389{
    390	int fd1, fd2, opt = 1;
    391
    392	fprintf(stderr, "Testing filter add without bind...\n");
    393	fd1 = socket(AF_INET, SOCK_DGRAM, 0);
    394	if (fd1 < 0)
    395		error(1, errno, "failed to create socket 1");
    396	fd2 = socket(AF_INET, SOCK_DGRAM, 0);
    397	if (fd2 < 0)
    398		error(1, errno, "failed to create socket 2");
    399	if (setsockopt(fd1, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)))
    400		error(1, errno, "failed to set SO_REUSEPORT on socket 1");
    401	if (setsockopt(fd2, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)))
    402		error(1, errno, "failed to set SO_REUSEPORT on socket 2");
    403
    404	attach_ebpf(fd1, 10);
    405	attach_cbpf(fd2, 10);
    406
    407	close(fd1);
    408	close(fd2);
    409}
    410
    411void enable_fastopen(void)
    412{
    413	int fd = open("/proc/sys/net/ipv4/tcp_fastopen", 0);
    414	int rw_mask = 3;  /* bit 1: client side; bit-2 server side */
    415	int val, size;
    416	char buf[16];
    417
    418	if (fd < 0)
    419		error(1, errno, "Unable to open tcp_fastopen sysctl");
    420	if (read(fd, buf, sizeof(buf)) <= 0)
    421		error(1, errno, "Unable to read tcp_fastopen sysctl");
    422	val = atoi(buf);
    423	close(fd);
    424
    425	if ((val & rw_mask) != rw_mask) {
    426		fd = open("/proc/sys/net/ipv4/tcp_fastopen", O_RDWR);
    427		if (fd < 0)
    428			error(1, errno,
    429			      "Unable to open tcp_fastopen sysctl for writing");
    430		val |= rw_mask;
    431		size = snprintf(buf, 16, "%d", val);
    432		if (write(fd, buf, size) <= 0)
    433			error(1, errno, "Unable to write tcp_fastopen sysctl");
    434		close(fd);
    435	}
    436}
    437
    438static struct rlimit rlim_old;
    439
    440static  __attribute__((constructor)) void main_ctor(void)
    441{
    442	getrlimit(RLIMIT_MEMLOCK, &rlim_old);
    443
    444	if (rlim_old.rlim_cur != RLIM_INFINITY) {
    445		struct rlimit rlim_new;
    446
    447		rlim_new.rlim_cur = rlim_old.rlim_cur + (1UL << 20);
    448		rlim_new.rlim_max = rlim_old.rlim_max + (1UL << 20);
    449		setrlimit(RLIMIT_MEMLOCK, &rlim_new);
    450	}
    451}
    452
    453static __attribute__((destructor)) void main_dtor(void)
    454{
    455	setrlimit(RLIMIT_MEMLOCK, &rlim_old);
    456}
    457
    458int main(void)
    459{
    460	fprintf(stderr, "---- IPv4 UDP ----\n");
    461	/* NOTE: UDP socket lookups traverse a different code path when there
    462	 * are > 10 sockets in a group.  Run the bpf test through both paths.
    463	 */
    464	test_reuseport_ebpf((struct test_params) {
    465		.recv_family = AF_INET,
    466		.send_family = AF_INET,
    467		.protocol = SOCK_DGRAM,
    468		.recv_socks = 10,
    469		.recv_port = 8000,
    470		.send_port_min = 9000});
    471	test_reuseport_ebpf((struct test_params) {
    472		.recv_family = AF_INET,
    473		.send_family = AF_INET,
    474		.protocol = SOCK_DGRAM,
    475		.recv_socks = 20,
    476		.recv_port = 8000,
    477		.send_port_min = 9000});
    478	test_reuseport_cbpf((struct test_params) {
    479		.recv_family = AF_INET,
    480		.send_family = AF_INET,
    481		.protocol = SOCK_DGRAM,
    482		.recv_socks = 10,
    483		.recv_port = 8001,
    484		.send_port_min = 9020});
    485	test_reuseport_cbpf((struct test_params) {
    486		.recv_family = AF_INET,
    487		.send_family = AF_INET,
    488		.protocol = SOCK_DGRAM,
    489		.recv_socks = 20,
    490		.recv_port = 8001,
    491		.send_port_min = 9020});
    492	test_extra_filter((struct test_params) {
    493		.recv_family = AF_INET,
    494		.protocol = SOCK_DGRAM,
    495		.recv_port = 8002});
    496	test_filter_no_reuseport((struct test_params) {
    497		.recv_family = AF_INET,
    498		.protocol = SOCK_DGRAM,
    499		.recv_port = 8008});
    500
    501	fprintf(stderr, "---- IPv6 UDP ----\n");
    502	test_reuseport_ebpf((struct test_params) {
    503		.recv_family = AF_INET6,
    504		.send_family = AF_INET6,
    505		.protocol = SOCK_DGRAM,
    506		.recv_socks = 10,
    507		.recv_port = 8003,
    508		.send_port_min = 9040});
    509	test_reuseport_ebpf((struct test_params) {
    510		.recv_family = AF_INET6,
    511		.send_family = AF_INET6,
    512		.protocol = SOCK_DGRAM,
    513		.recv_socks = 20,
    514		.recv_port = 8003,
    515		.send_port_min = 9040});
    516	test_reuseport_cbpf((struct test_params) {
    517		.recv_family = AF_INET6,
    518		.send_family = AF_INET6,
    519		.protocol = SOCK_DGRAM,
    520		.recv_socks = 10,
    521		.recv_port = 8004,
    522		.send_port_min = 9060});
    523	test_reuseport_cbpf((struct test_params) {
    524		.recv_family = AF_INET6,
    525		.send_family = AF_INET6,
    526		.protocol = SOCK_DGRAM,
    527		.recv_socks = 20,
    528		.recv_port = 8004,
    529		.send_port_min = 9060});
    530	test_extra_filter((struct test_params) {
    531		.recv_family = AF_INET6,
    532		.protocol = SOCK_DGRAM,
    533		.recv_port = 8005});
    534	test_filter_no_reuseport((struct test_params) {
    535		.recv_family = AF_INET6,
    536		.protocol = SOCK_DGRAM,
    537		.recv_port = 8009});
    538
    539	fprintf(stderr, "---- IPv6 UDP w/ mapped IPv4 ----\n");
    540	test_reuseport_ebpf((struct test_params) {
    541		.recv_family = AF_INET6,
    542		.send_family = AF_INET,
    543		.protocol = SOCK_DGRAM,
    544		.recv_socks = 20,
    545		.recv_port = 8006,
    546		.send_port_min = 9080});
    547	test_reuseport_ebpf((struct test_params) {
    548		.recv_family = AF_INET6,
    549		.send_family = AF_INET,
    550		.protocol = SOCK_DGRAM,
    551		.recv_socks = 10,
    552		.recv_port = 8006,
    553		.send_port_min = 9080});
    554	test_reuseport_cbpf((struct test_params) {
    555		.recv_family = AF_INET6,
    556		.send_family = AF_INET,
    557		.protocol = SOCK_DGRAM,
    558		.recv_socks = 10,
    559		.recv_port = 8007,
    560		.send_port_min = 9100});
    561	test_reuseport_cbpf((struct test_params) {
    562		.recv_family = AF_INET6,
    563		.send_family = AF_INET,
    564		.protocol = SOCK_DGRAM,
    565		.recv_socks = 20,
    566		.recv_port = 8007,
    567		.send_port_min = 9100});
    568
    569	/* TCP fastopen is required for the TCP tests */
    570	enable_fastopen();
    571	fprintf(stderr, "---- IPv4 TCP ----\n");
    572	test_reuseport_ebpf((struct test_params) {
    573		.recv_family = AF_INET,
    574		.send_family = AF_INET,
    575		.protocol = SOCK_STREAM,
    576		.recv_socks = 10,
    577		.recv_port = 8008,
    578		.send_port_min = 9120});
    579	test_reuseport_cbpf((struct test_params) {
    580		.recv_family = AF_INET,
    581		.send_family = AF_INET,
    582		.protocol = SOCK_STREAM,
    583		.recv_socks = 10,
    584		.recv_port = 8009,
    585		.send_port_min = 9160});
    586	test_extra_filter((struct test_params) {
    587		.recv_family = AF_INET,
    588		.protocol = SOCK_STREAM,
    589		.recv_port = 8010});
    590	test_filter_no_reuseport((struct test_params) {
    591		.recv_family = AF_INET,
    592		.protocol = SOCK_STREAM,
    593		.recv_port = 8011});
    594
    595	fprintf(stderr, "---- IPv6 TCP ----\n");
    596	test_reuseport_ebpf((struct test_params) {
    597		.recv_family = AF_INET6,
    598		.send_family = AF_INET6,
    599		.protocol = SOCK_STREAM,
    600		.recv_socks = 10,
    601		.recv_port = 8012,
    602		.send_port_min = 9200});
    603	test_reuseport_cbpf((struct test_params) {
    604		.recv_family = AF_INET6,
    605		.send_family = AF_INET6,
    606		.protocol = SOCK_STREAM,
    607		.recv_socks = 10,
    608		.recv_port = 8013,
    609		.send_port_min = 9240});
    610	test_extra_filter((struct test_params) {
    611		.recv_family = AF_INET6,
    612		.protocol = SOCK_STREAM,
    613		.recv_port = 8014});
    614	test_filter_no_reuseport((struct test_params) {
    615		.recv_family = AF_INET6,
    616		.protocol = SOCK_STREAM,
    617		.recv_port = 8015});
    618
    619	fprintf(stderr, "---- IPv6 TCP w/ mapped IPv4 ----\n");
    620	test_reuseport_ebpf((struct test_params) {
    621		.recv_family = AF_INET6,
    622		.send_family = AF_INET,
    623		.protocol = SOCK_STREAM,
    624		.recv_socks = 10,
    625		.recv_port = 8016,
    626		.send_port_min = 9320});
    627	test_reuseport_cbpf((struct test_params) {
    628		.recv_family = AF_INET6,
    629		.send_family = AF_INET,
    630		.protocol = SOCK_STREAM,
    631		.recv_socks = 10,
    632		.recv_port = 8017,
    633		.send_port_min = 9360});
    634
    635	test_filter_without_bind();
    636
    637	fprintf(stderr, "SUCCESS\n");
    638	return 0;
    639}