Commit 33181bb8 authored by Stanislav Fomichev's avatar Stanislav Fomichev Committed by Daniel Borkmann
Browse files

selftests/bpf: Generalize helpers to control background listener 



Move the following routines that let us start a background listener
thread and connect to a server by fd to the test_prog:
* start_server - socket+bind+listen
* connect_to_fd - connect to the server identified by fd

These will be used in the next commit.

Also, extend these helpers to support AF_INET6 and accept the family
as an argument.

v5:
* drop pthread.h (Martin KaFai Lau)
* add SO_SNDTIMEO (Martin KaFai Lau)

v4:
* export extra helper to start server without a thread (Martin KaFai Lau)
* tcp_rtt is no longer starting background thread (Martin KaFai Lau)

v2:
* put helpers into network_helpers.c (Andrii Nakryiko)

Signed-off-by: default avatarStanislav Fomichev <sdf@google.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Acked-by: default avatarAndrey Ignatov <rdna@fb.com>
Acked-by: default avatarMartin KaFai Lau <kafai@fb.com>
Link: https://lore.kernel.org/bpf/20200508174611.228805-2-sdf@google.com
parent 2b6c6f07

tools/testing/selftests/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -354,7 +354,7 @@ endef 
TRUNNER_TESTS_DIR := prog_tests

TRUNNER_BPF_PROGS_DIR := progs

TRUNNER_EXTRA_SOURCES := test_progs.c cgroup_helpers.c trace_helpers.c	\

			 flow_dissector_load.h

			 network_helpers.c flow_dissector_load.h

TRUNNER_EXTRA_FILES := $(OUTPUT)/urandom_read				\

		       $(wildcard progs/btf_dump_test_case_*.c)

TRUNNER_BPF_BUILD_RULE := CLANG_BPF_BUILD_RULE

tools/testing/selftests/bpf/network_helpers.c

0 → 100644
+93 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

#include <errno.h>

#include <stdbool.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <linux/err.h>

#include <linux/in.h>

#include <linux/in6.h>



#include "network_helpers.h"



#define clean_errno() (errno == 0 ? "None" : strerror(errno))

#define log_err(MSG, ...) fprintf(stderr, "(%s:%d: errno: %s) " MSG "\n", \

	__FILE__, __LINE__, clean_errno(), ##__VA_ARGS__)



int start_server(int family, int type)

{

	struct sockaddr_storage addr = {};

	socklen_t len;

	int fd;



	if (family == AF_INET) {

		struct sockaddr_in *sin = (void *)&addr;



		sin->sin_family = AF_INET;

		len = sizeof(*sin);

	} else {

		struct sockaddr_in6 *sin6 = (void *)&addr;



		sin6->sin6_family = AF_INET6;

		len = sizeof(*sin6);

	}



	fd = socket(family, type | SOCK_NONBLOCK, 0);

	if (fd < 0) {

		log_err("Failed to create server socket");

		return -1;

	}



	if (bind(fd, (const struct sockaddr *)&addr, len) < 0) {

		log_err("Failed to bind socket");

		close(fd);

		return -1;

	}



	if (type == SOCK_STREAM) {

		if (listen(fd, 1) < 0) {

			log_err("Failed to listed on socket");

			close(fd);

			return -1;

		}

	}



	return fd;

}



static const struct timeval timeo_sec = { .tv_sec = 3 };

static const size_t timeo_optlen = sizeof(timeo_sec);



int connect_to_fd(int family, int type, int server_fd)

{

	struct sockaddr_storage addr;

	socklen_t len = sizeof(addr);

	int fd;



	fd = socket(family, type, 0);

	if (fd < 0) {

		log_err("Failed to create client socket");

		return -1;

	}



	if (setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo_sec, timeo_optlen)) {

		log_err("Failed to set SO_RCVTIMEO");

		goto out;

	}



	if (getsockname(server_fd, (struct sockaddr *)&addr, &len)) {

		log_err("Failed to get server addr");

		goto out;

	}



	if (connect(fd, (const struct sockaddr *)&addr, len) < 0) {

		log_err("Fail to connect to server with family %d", family);

		goto out;

	}



	return fd;



out:

	close(fd);

	return -1;

}

tools/testing/selftests/bpf/network_helpers.h

0 → 100644
+10 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

#ifndef __NETWORK_HELPERS_H

#define __NETWORK_HELPERS_H

#include <sys/socket.h>

#include <sys/types.h>



int start_server(int family, int type);

int connect_to_fd(int family, int type, int server_fd);



#endif

tools/testing/selftests/bpf/prog_tests/tcp_rtt.c

+4 −112
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <test_progs.h>

#include "cgroup_helpers.h"

#include "network_helpers.h"



struct tcp_rtt_storage {

	__u32 invoked;
@@ -87,34 +88,6 @@ static int verify_sk(int map_fd, int client_fd, const char *msg, __u32 invoked, 
	return err;

}



static int connect_to_server(int server_fd)

{

	struct sockaddr_storage addr;

	socklen_t len = sizeof(addr);

	int fd;



	fd = socket(AF_INET, SOCK_STREAM, 0);

	if (fd < 0) {

		log_err("Failed to create client socket");

		return -1;

	}



	if (getsockname(server_fd, (struct sockaddr *)&addr, &len)) {

		log_err("Failed to get server addr");

		goto out;

	}



	if (connect(fd, (const struct sockaddr *)&addr, len) < 0) {

		log_err("Fail to connect to server");

		goto out;

	}



	return fd;



out:

	close(fd);

	return -1;

}



static int run_test(int cgroup_fd, int server_fd)

{
@@ -145,7 +118,7 @@ static int run_test(int cgroup_fd, int server_fd) 
		goto close_bpf_object;

	}



	client_fd = connect_to_server(server_fd);

	client_fd = connect_to_fd(AF_INET, SOCK_STREAM, server_fd);

	if (client_fd < 0) {

		err = -1;

		goto close_bpf_object;
@@ -180,103 +153,22 @@ close_bpf_object: 
	return err;

}



static int start_server(void)

{

	struct sockaddr_in addr = {

		.sin_family = AF_INET,

		.sin_addr.s_addr = htonl(INADDR_LOOPBACK),

	};

	int fd;



	fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);

	if (fd < 0) {

		log_err("Failed to create server socket");

		return -1;

	}



	if (bind(fd, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {

		log_err("Failed to bind socket");

		close(fd);

		return -1;

	}



	return fd;

}



static pthread_mutex_t server_started_mtx = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t server_started = PTHREAD_COND_INITIALIZER;

static volatile bool server_done = false;



static void *server_thread(void *arg)

{

	struct sockaddr_storage addr;

	socklen_t len = sizeof(addr);

	int fd = *(int *)arg;

	int client_fd;

	int err;



	err = listen(fd, 1);



	pthread_mutex_lock(&server_started_mtx);

	pthread_cond_signal(&server_started);

	pthread_mutex_unlock(&server_started_mtx);



	if (CHECK_FAIL(err < 0)) {

		perror("Failed to listed on socket");

		return ERR_PTR(err);

	}



	while (true) {

		client_fd = accept(fd, (struct sockaddr *)&addr, &len);

		if (client_fd == -1 && errno == EAGAIN) {

			usleep(50);

			continue;

		}

		break;

	}

	if (CHECK_FAIL(client_fd < 0)) {

		perror("Failed to accept client");

		return ERR_PTR(err);

	}



	while (!server_done)

		usleep(50);



	close(client_fd);



	return NULL;

}



void test_tcp_rtt(void)

{

	int server_fd, cgroup_fd;

	pthread_t tid;

	void *server_res;



	cgroup_fd = test__join_cgroup("/tcp_rtt");

	if (CHECK_FAIL(cgroup_fd < 0))

		return;



	server_fd = start_server();

	server_fd = start_server(AF_INET, SOCK_STREAM);

	if (CHECK_FAIL(server_fd < 0))

		goto close_cgroup_fd;



	if (CHECK_FAIL(pthread_create(&tid, NULL, server_thread,

				      (void *)&server_fd)))

		goto close_server_fd;



	pthread_mutex_lock(&server_started_mtx);

	pthread_cond_wait(&server_started, &server_started_mtx);

	pthread_mutex_unlock(&server_started_mtx);



	CHECK_FAIL(run_test(cgroup_fd, server_fd));



	server_done = true;

	CHECK_FAIL(pthread_join(tid, &server_res));

	CHECK_FAIL(IS_ERR(server_res));



close_server_fd:

	close(server_fd);



close_cgroup_fd:

	close(cgroup_fd);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE