selftests/bpf: Retire test_sock.c (eea6c14c) · Commits · git / linux-net

tools/testing/selftests/bpf/.gitignore

+0 −1

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@ fixdep
		/test_progs-cpuv4
		test_verifier_log
		feature
		test_sock
		urandom_read
		test_sockmap
		test_lirc_mode2_user

tools/testing/selftests/bpf/Makefile

+1 −2

Original line number	Diff line number	Diff line
		@@ -84,7 +84,7 @@ endif

		# Order correspond to 'make run_tests' order
		TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \
		test_sock test_sockmap \
		test_sockmap \
		test_tcpnotify_user test_sysctl \
		test_progs-no_alu32
		TEST_INST_SUBDIRS := no_alu32
		@@ -335,7 +335,6 @@ JSON_WRITER := $(OUTPUT)/json_writer.o
		CAP_HELPERS := $(OUTPUT)/cap_helpers.o
		NETWORK_HELPERS := $(OUTPUT)/network_helpers.o

		$(OUTPUT)/test_sock: $(CGROUP_HELPERS) $(TESTING_HELPERS)
		$(OUTPUT)/test_sockmap: $(CGROUP_HELPERS) $(TESTING_HELPERS)
		$(OUTPUT)/test_tcpnotify_user: $(CGROUP_HELPERS) $(TESTING_HELPERS) $(TRACE_HELPERS)
		$(OUTPUT)/test_sock_fields: $(CGROUP_HELPERS) $(TESTING_HELPERS)

tools/testing/selftests/bpf/test_sock.c

deleted100644 → 0

+0 −231

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		// Copyright (c) 2018 Facebook

		#include <stdio.h>
		#include <unistd.h>

		#include <arpa/inet.h>
		#include <sys/types.h>
		#include <sys/socket.h>

		#include <linux/filter.h>

		#include <bpf/bpf.h>

		#include "cgroup_helpers.h"
		#include <bpf/bpf_endian.h>
		#include "bpf_util.h"

		#define CG_PATH "/foo"
		#define MAX_INSNS 512

		char bpf_log_buf[BPF_LOG_BUF_SIZE];
		static bool verbose = false;

		struct sock_test {
		const char *descr;
		/* BPF prog properties */
		struct bpf_insn insns[MAX_INSNS];
		enum bpf_attach_type expected_attach_type;
		enum bpf_attach_type attach_type;
		/* Socket properties */
		int domain;
		int type;
		/* Endpoint to bind() to */
		const char *ip;
		unsigned short port;
		unsigned short port_retry;
		/* Expected test result */
		enum {
		LOAD_REJECT,
		ATTACH_REJECT,
		BIND_REJECT,
		SUCCESS,
		RETRY_SUCCESS,
		RETRY_REJECT
		} result;
		};

		static struct sock_test tests[] = {
		};

		static size_t probe_prog_length(const struct bpf_insn *fp)
		{
		size_t len;

		for (len = MAX_INSNS - 1; len > 0; --len)
		if (fp[len].code != 0 \|\| fp[len].imm != 0)
		break;
		return len + 1;
		}

		static int load_sock_prog(const struct bpf_insn *prog,
		enum bpf_attach_type attach_type)
		{
		LIBBPF_OPTS(bpf_prog_load_opts, opts);
		int ret, insn_cnt;

		insn_cnt = probe_prog_length(prog);

		opts.expected_attach_type = attach_type;
		opts.log_buf = bpf_log_buf;
		opts.log_size = BPF_LOG_BUF_SIZE;
		opts.log_level = 2;

		ret = bpf_prog_load(BPF_PROG_TYPE_CGROUP_SOCK, NULL, "GPL", prog, insn_cnt, &opts);
		if (verbose && ret < 0)
		fprintf(stderr, "%s\n", bpf_log_buf);

		return ret;
		}

		static int attach_sock_prog(int cgfd, int progfd,
		enum bpf_attach_type attach_type)
		{
		return bpf_prog_attach(progfd, cgfd, attach_type, BPF_F_ALLOW_OVERRIDE);
		}

		static int bind_sock(int domain, int type, const char *ip,
		unsigned short port, unsigned short port_retry)
		{
		struct sockaddr_storage addr;
		struct sockaddr_in6 *addr6;
		struct sockaddr_in *addr4;
		int sockfd = -1;
		socklen_t len;
		int res = SUCCESS;

		sockfd = socket(domain, type, 0);
		if (sockfd < 0)
		goto err;

		memset(&addr, 0, sizeof(addr));

		if (domain == AF_INET) {
		len = sizeof(struct sockaddr_in);
		addr4 = (struct sockaddr_in *)&addr;
		addr4->sin_family = domain;
		addr4->sin_port = htons(port);
		if (inet_pton(domain, ip, (void *)&addr4->sin_addr) != 1)
		goto err;
		} else if (domain == AF_INET6) {
		len = sizeof(struct sockaddr_in6);
		addr6 = (struct sockaddr_in6 *)&addr;
		addr6->sin6_family = domain;
		addr6->sin6_port = htons(port);
		if (inet_pton(domain, ip, (void *)&addr6->sin6_addr) != 1)
		goto err;
		} else {
		goto err;
		}

		if (bind(sockfd, (const struct sockaddr *)&addr, len) == -1) {
		/* sys_bind() may fail for different reasons, errno has to be
		* checked to confirm that BPF program rejected it.
		*/
		if (errno != EPERM)
		goto err;
		if (port_retry)
		goto retry;
		res = BIND_REJECT;
		goto out;
		}

		goto out;
		retry:
		if (domain == AF_INET)
		addr4->sin_port = htons(port_retry);
		else
		addr6->sin6_port = htons(port_retry);
		if (bind(sockfd, (const struct sockaddr *)&addr, len) == -1) {
		if (errno != EPERM)
		goto err;
		res = RETRY_REJECT;
		} else {
		res = RETRY_SUCCESS;
		}
		goto out;
		err:
		res = -1;
		out:
		close(sockfd);
		return res;
		}

		static int run_test_case(int cgfd, const struct sock_test *test)
		{
		int progfd = -1;
		int err = 0;
		int res;

		printf("Test case: %s .. ", test->descr);
		progfd = load_sock_prog(test->insns, test->expected_attach_type);
		if (progfd < 0) {
		if (test->result == LOAD_REJECT)
		goto out;
		else
		goto err;
		}

		if (attach_sock_prog(cgfd, progfd, test->attach_type) < 0) {
		if (test->result == ATTACH_REJECT)
		goto out;
		else
		goto err;
		}

		res = bind_sock(test->domain, test->type, test->ip, test->port,
		test->port_retry);
		if (res > 0 && test->result == res)
		goto out;

		err:
		err = -1;
		out:
		/* Detaching w/o checking return code: best effort attempt. */
		if (progfd != -1)
		bpf_prog_detach(cgfd, test->attach_type);
		close(progfd);
		printf("[%s]\n", err ? "FAIL" : "PASS");
		return err;
		}

		static int run_tests(int cgfd)
		{
		int passes = 0;
		int fails = 0;
		int i;

		for (i = 0; i < ARRAY_SIZE(tests); ++i) {
		if (run_test_case(cgfd, &tests[i]))
		++fails;
		else
		++passes;
		}
		printf("Summary: %d PASSED, %d FAILED\n", passes, fails);
		return fails ? -1 : 0;
		}

		int main(int argc, char **argv)
		{
		int cgfd = -1;
		int err = 0;

		cgfd = cgroup_setup_and_join(CG_PATH);
		if (cgfd < 0)
		goto err;

		/* Use libbpf 1.0 API mode */
		libbpf_set_strict_mode(LIBBPF_STRICT_ALL);

		if (run_tests(cgfd))
		goto err;

		goto out;
		err:
		err = -1;
		out:
		close(cgfd);
		cleanup_cgroup_environment();
		return err;
		}