Commit ea5bade9 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'split-test_progs' 



Stanislav Fomichev says:

====================
Recently we had linux-next bpf/bpf-next conflict when we added new
functionality to the test_progs.c at the same location. Let's split
test_progs.c the same way we recently split test_verifier.c.

I follow the same patten we did in commit 2dfb4012 ("selftests: bpf:
prepare for break up of verifier tests") for verifier: create
scaffolding to support dedicated files and slowly move the tests into
separate files.

The first patch adds scaffolding, subsequent patches move progs into
separate files.

In theory, many of the standalone tests can be migrated to this new
framework as well. They get the benefit of common CHECK macro and
bpf_find_map function which a lot of standalone tests need to redefine.

v3 changes:
* respin on top of commit ebace0e9 ("selftests/bpf: use
  __bpf_constant_htons in test_prog.c for flow dissector")
* put bpf_rlimit.h into test_progs.c instead of test_progs.h

v2 changes:
* added cover letter, added more description about file structure
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents 0d7f6827 886225bb

tools/testing/selftests/bpf/Makefile

+25 −2
Original line number Diff line number Diff line
@@ -165,7 +165,11 @@ $(ALU32_BUILD_DIR)/urandom_read: $(OUTPUT)/urandom_read 
$(ALU32_BUILD_DIR)/test_progs_32: test_progs.c $(ALU32_BUILD_DIR) \

						$(ALU32_BUILD_DIR)/urandom_read

	$(CC) $(CFLAGS) -o $(ALU32_BUILD_DIR)/test_progs_32 $< \

		trace_helpers.c $(OUTPUT)/libbpf.a $(LDLIBS)

		trace_helpers.c prog_tests/*.c $(OUTPUT)/libbpf.a $(LDLIBS)



$(ALU32_BUILD_DIR)/test_progs_32: $(PROG_TESTS_H)

$(ALU32_BUILD_DIR)/test_progs_32: CFLAGS += -I$(OUTPUT)

$(ALU32_BUILD_DIR)/test_progs_32: prog_tests/*.c



$(ALU32_BUILD_DIR)/%.o: progs/%.c $(ALU32_BUILD_DIR) \

					$(ALU32_BUILD_DIR)/test_progs_32
@@ -196,6 +200,25 @@ ifeq ($(DWARF2BTF),y) 
	$(BTF_PAHOLE) -J $@

endif



PROG_TESTS_H := $(OUTPUT)/prog_tests/tests.h

$(OUTPUT)/test_progs: $(PROG_TESTS_H)

$(OUTPUT)/test_progs: CFLAGS += -I$(OUTPUT)

$(OUTPUT)/test_progs: prog_tests/*.c



PROG_TESTS_FILES := $(wildcard prog_tests/*.c)

$(PROG_TESTS_H): $(PROG_TESTS_FILES)

	$(shell ( cd prog_tests/

		  echo '/* Generated header, do not edit */'; \

		  echo '#ifdef DECLARE'; \

		  ls *.c 2> /dev/null | \

			sed -e 's@\([^\.]*\)\.c@extern void test_\1(void);@'; \

		  echo '#endif'; \

		  echo '#ifdef CALL'; \

		  ls *.c 2> /dev/null | \

			sed -e 's@\([^\.]*\)\.c@test_\1();@'; \

		  echo '#endif' \

		 ) > $(PROG_TESTS_H))



VERIFIER_TESTS_H := $(OUTPUT)/verifier/tests.h

$(OUTPUT)/test_verifier: $(VERIFIER_TESTS_H)

$(OUTPUT)/test_verifier: CFLAGS += -I$(OUTPUT)
@@ -211,4 +234,4 @@ $(OUTPUT)/verifier/tests.h: $(VERIFIER_TEST_FILES) 
		 ) > $(VERIFIER_TESTS_H))



EXTRA_CLEAN := $(TEST_CUSTOM_PROGS) $(ALU32_BUILD_DIR) \

	$(VERIFIER_TESTS_H)
 
	$(VERIFIER_TESTS_H) $(PROG_TESTS_H)

tools/testing/selftests/bpf/prog_tests/.gitignore

0 → 100644
+1 −0
Original line number Diff line number Diff line 
tests.h

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

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

#include <test_progs.h>



void test_bpf_obj_id(void)

{

	const __u64 array_magic_value = 0xfaceb00c;

	const __u32 array_key = 0;

	const int nr_iters = 2;

	const char *file = "./test_obj_id.o";

	const char *expected_prog_name = "test_obj_id";

	const char *expected_map_name = "test_map_id";

	const __u64 nsec_per_sec = 1000000000;



	struct bpf_object *objs[nr_iters];

	int prog_fds[nr_iters], map_fds[nr_iters];

	/* +1 to test for the info_len returned by kernel */

	struct bpf_prog_info prog_infos[nr_iters + 1];

	struct bpf_map_info map_infos[nr_iters + 1];

	/* Each prog only uses one map. +1 to test nr_map_ids

	 * returned by kernel.

	 */

	__u32 map_ids[nr_iters + 1];

	char jited_insns[128], xlated_insns[128], zeros[128];

	__u32 i, next_id, info_len, nr_id_found, duration = 0;

	struct timespec real_time_ts, boot_time_ts;

	int err = 0;

	__u64 array_value;

	uid_t my_uid = getuid();

	time_t now, load_time;



	err = bpf_prog_get_fd_by_id(0);

	CHECK(err >= 0 || errno != ENOENT,

	      "get-fd-by-notexist-prog-id", "err %d errno %d\n", err, errno);



	err = bpf_map_get_fd_by_id(0);

	CHECK(err >= 0 || errno != ENOENT,

	      "get-fd-by-notexist-map-id", "err %d errno %d\n", err, errno);



	for (i = 0; i < nr_iters; i++)

		objs[i] = NULL;



	/* Check bpf_obj_get_info_by_fd() */

	bzero(zeros, sizeof(zeros));

	for (i = 0; i < nr_iters; i++) {

		now = time(NULL);

		err = bpf_prog_load(file, BPF_PROG_TYPE_SOCKET_FILTER,

				    &objs[i], &prog_fds[i]);

		/* test_obj_id.o is a dumb prog. It should never fail

		 * to load.

		 */

		if (err)

			error_cnt++;

		assert(!err);



		/* Insert a magic value to the map */

		map_fds[i] = bpf_find_map(__func__, objs[i], "test_map_id");

		assert(map_fds[i] >= 0);

		err = bpf_map_update_elem(map_fds[i], &array_key,

					  &array_magic_value, 0);

		assert(!err);



		/* Check getting map info */

		info_len = sizeof(struct bpf_map_info) * 2;

		bzero(&map_infos[i], info_len);

		err = bpf_obj_get_info_by_fd(map_fds[i], &map_infos[i],

					     &info_len);

		if (CHECK(err ||

			  map_infos[i].type != BPF_MAP_TYPE_ARRAY ||

			  map_infos[i].key_size != sizeof(__u32) ||

			  map_infos[i].value_size != sizeof(__u64) ||

			  map_infos[i].max_entries != 1 ||

			  map_infos[i].map_flags != 0 ||

			  info_len != sizeof(struct bpf_map_info) ||

			  strcmp((char *)map_infos[i].name, expected_map_name),

			  "get-map-info(fd)",

			  "err %d errno %d type %d(%d) info_len %u(%Zu) key_size %u value_size %u max_entries %u map_flags %X name %s(%s)\n",

			  err, errno,

			  map_infos[i].type, BPF_MAP_TYPE_ARRAY,

			  info_len, sizeof(struct bpf_map_info),

			  map_infos[i].key_size,

			  map_infos[i].value_size,

			  map_infos[i].max_entries,

			  map_infos[i].map_flags,

			  map_infos[i].name, expected_map_name))

			goto done;



		/* Check getting prog info */

		info_len = sizeof(struct bpf_prog_info) * 2;

		bzero(&prog_infos[i], info_len);

		bzero(jited_insns, sizeof(jited_insns));

		bzero(xlated_insns, sizeof(xlated_insns));

		prog_infos[i].jited_prog_insns = ptr_to_u64(jited_insns);

		prog_infos[i].jited_prog_len = sizeof(jited_insns);

		prog_infos[i].xlated_prog_insns = ptr_to_u64(xlated_insns);

		prog_infos[i].xlated_prog_len = sizeof(xlated_insns);

		prog_infos[i].map_ids = ptr_to_u64(map_ids + i);

		prog_infos[i].nr_map_ids = 2;

		err = clock_gettime(CLOCK_REALTIME, &real_time_ts);

		assert(!err);

		err = clock_gettime(CLOCK_BOOTTIME, &boot_time_ts);

		assert(!err);

		err = bpf_obj_get_info_by_fd(prog_fds[i], &prog_infos[i],

					     &info_len);

		load_time = (real_time_ts.tv_sec - boot_time_ts.tv_sec)

			+ (prog_infos[i].load_time / nsec_per_sec);

		if (CHECK(err ||

			  prog_infos[i].type != BPF_PROG_TYPE_SOCKET_FILTER ||

			  info_len != sizeof(struct bpf_prog_info) ||

			  (jit_enabled && !prog_infos[i].jited_prog_len) ||

			  (jit_enabled &&

			   !memcmp(jited_insns, zeros, sizeof(zeros))) ||

			  !prog_infos[i].xlated_prog_len ||

			  !memcmp(xlated_insns, zeros, sizeof(zeros)) ||

			  load_time < now - 60 || load_time > now + 60 ||

			  prog_infos[i].created_by_uid != my_uid ||

			  prog_infos[i].nr_map_ids != 1 ||

			  *(int *)(long)prog_infos[i].map_ids != map_infos[i].id ||

			  strcmp((char *)prog_infos[i].name, expected_prog_name),

			  "get-prog-info(fd)",

			  "err %d errno %d i %d type %d(%d) info_len %u(%Zu) jit_enabled %d jited_prog_len %u xlated_prog_len %u jited_prog %d xlated_prog %d load_time %lu(%lu) uid %u(%u) nr_map_ids %u(%u) map_id %u(%u) name %s(%s)\n",

			  err, errno, i,

			  prog_infos[i].type, BPF_PROG_TYPE_SOCKET_FILTER,

			  info_len, sizeof(struct bpf_prog_info),

			  jit_enabled,

			  prog_infos[i].jited_prog_len,

			  prog_infos[i].xlated_prog_len,

			  !!memcmp(jited_insns, zeros, sizeof(zeros)),

			  !!memcmp(xlated_insns, zeros, sizeof(zeros)),

			  load_time, now,

			  prog_infos[i].created_by_uid, my_uid,

			  prog_infos[i].nr_map_ids, 1,

			  *(int *)(long)prog_infos[i].map_ids, map_infos[i].id,

			  prog_infos[i].name, expected_prog_name))

			goto done;

	}



	/* Check bpf_prog_get_next_id() */

	nr_id_found = 0;

	next_id = 0;

	while (!bpf_prog_get_next_id(next_id, &next_id)) {

		struct bpf_prog_info prog_info = {};

		__u32 saved_map_id;

		int prog_fd;



		info_len = sizeof(prog_info);



		prog_fd = bpf_prog_get_fd_by_id(next_id);

		if (prog_fd < 0 && errno == ENOENT)

			/* The bpf_prog is in the dead row */

			continue;

		if (CHECK(prog_fd < 0, "get-prog-fd(next_id)",

			  "prog_fd %d next_id %d errno %d\n",

			  prog_fd, next_id, errno))

			break;



		for (i = 0; i < nr_iters; i++)

			if (prog_infos[i].id == next_id)

				break;



		if (i == nr_iters)

			continue;



		nr_id_found++;



		/* Negative test:

		 * prog_info.nr_map_ids = 1

		 * prog_info.map_ids = NULL

		 */

		prog_info.nr_map_ids = 1;

		err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len);

		if (CHECK(!err || errno != EFAULT,

			  "get-prog-fd-bad-nr-map-ids", "err %d errno %d(%d)",

			  err, errno, EFAULT))

			break;

		bzero(&prog_info, sizeof(prog_info));

		info_len = sizeof(prog_info);



		saved_map_id = *(int *)((long)prog_infos[i].map_ids);

		prog_info.map_ids = prog_infos[i].map_ids;

		prog_info.nr_map_ids = 2;

		err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len);

		prog_infos[i].jited_prog_insns = 0;

		prog_infos[i].xlated_prog_insns = 0;

		CHECK(err || info_len != sizeof(struct bpf_prog_info) ||

		      memcmp(&prog_info, &prog_infos[i], info_len) ||

		      *(int *)(long)prog_info.map_ids != saved_map_id,

		      "get-prog-info(next_id->fd)",

		      "err %d errno %d info_len %u(%Zu) memcmp %d map_id %u(%u)\n",

		      err, errno, info_len, sizeof(struct bpf_prog_info),

		      memcmp(&prog_info, &prog_infos[i], info_len),

		      *(int *)(long)prog_info.map_ids, saved_map_id);

		close(prog_fd);

	}

	CHECK(nr_id_found != nr_iters,

	      "check total prog id found by get_next_id",

	      "nr_id_found %u(%u)\n",

	      nr_id_found, nr_iters);



	/* Check bpf_map_get_next_id() */

	nr_id_found = 0;

	next_id = 0;

	while (!bpf_map_get_next_id(next_id, &next_id)) {

		struct bpf_map_info map_info = {};

		int map_fd;



		info_len = sizeof(map_info);



		map_fd = bpf_map_get_fd_by_id(next_id);

		if (map_fd < 0 && errno == ENOENT)

			/* The bpf_map is in the dead row */

			continue;

		if (CHECK(map_fd < 0, "get-map-fd(next_id)",

			  "map_fd %d next_id %u errno %d\n",

			  map_fd, next_id, errno))

			break;



		for (i = 0; i < nr_iters; i++)

			if (map_infos[i].id == next_id)

				break;



		if (i == nr_iters)

			continue;



		nr_id_found++;



		err = bpf_map_lookup_elem(map_fd, &array_key, &array_value);

		assert(!err);



		err = bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len);

		CHECK(err || info_len != sizeof(struct bpf_map_info) ||

		      memcmp(&map_info, &map_infos[i], info_len) ||

		      array_value != array_magic_value,

		      "check get-map-info(next_id->fd)",

		      "err %d errno %d info_len %u(%Zu) memcmp %d array_value %llu(%llu)\n",

		      err, errno, info_len, sizeof(struct bpf_map_info),

		      memcmp(&map_info, &map_infos[i], info_len),

		      array_value, array_magic_value);



		close(map_fd);

	}

	CHECK(nr_id_found != nr_iters,

	      "check total map id found by get_next_id",

	      "nr_id_found %u(%u)\n",

	      nr_id_found, nr_iters);



done:

	for (i = 0; i < nr_iters; i++)

		bpf_object__close(objs[i]);

}

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

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

#include <test_progs.h>



#define CHECK_FLOW_KEYS(desc, got, expected)				\

	CHECK(memcmp(&got, &expected, sizeof(got)) != 0,		\

	      desc,							\

	      "nhoff=%u/%u "						\

	      "thoff=%u/%u "						\

	      "addr_proto=0x%x/0x%x "					\

	      "is_frag=%u/%u "						\

	      "is_first_frag=%u/%u "					\

	      "is_encap=%u/%u "						\

	      "n_proto=0x%x/0x%x "					\

	      "sport=%u/%u "						\

	      "dport=%u/%u\n",						\

	      got.nhoff, expected.nhoff,				\

	      got.thoff, expected.thoff,				\

	      got.addr_proto, expected.addr_proto,			\

	      got.is_frag, expected.is_frag,				\

	      got.is_first_frag, expected.is_first_frag,		\

	      got.is_encap, expected.is_encap,				\

	      got.n_proto, expected.n_proto,				\

	      got.sport, expected.sport,				\

	      got.dport, expected.dport)



static struct bpf_flow_keys pkt_v4_flow_keys = {

	.nhoff = 0,

	.thoff = sizeof(struct iphdr),

	.addr_proto = ETH_P_IP,

	.ip_proto = IPPROTO_TCP,

	.n_proto = __bpf_constant_htons(ETH_P_IP),

};



static struct bpf_flow_keys pkt_v6_flow_keys = {

	.nhoff = 0,

	.thoff = sizeof(struct ipv6hdr),

	.addr_proto = ETH_P_IPV6,

	.ip_proto = IPPROTO_TCP,

	.n_proto = __bpf_constant_htons(ETH_P_IPV6),

};



void test_flow_dissector(void)

{

	struct bpf_flow_keys flow_keys;

	struct bpf_object *obj;

	__u32 duration, retval;

	int err, prog_fd;

	__u32 size;



	err = bpf_flow_load(&obj, "./bpf_flow.o", "flow_dissector",

			    "jmp_table", &prog_fd);

	if (err) {

		error_cnt++;

		return;

	}



	err = bpf_prog_test_run(prog_fd, 10, &pkt_v4, sizeof(pkt_v4),

				&flow_keys, &size, &retval, &duration);

	CHECK(size != sizeof(flow_keys) || err || retval != 1, "ipv4",

	      "err %d errno %d retval %d duration %d size %u/%lu\n",

	      err, errno, retval, duration, size, sizeof(flow_keys));

	CHECK_FLOW_KEYS("ipv4_flow_keys", flow_keys, pkt_v4_flow_keys);



	err = bpf_prog_test_run(prog_fd, 10, &pkt_v6, sizeof(pkt_v6),

				&flow_keys, &size, &retval, &duration);

	CHECK(size != sizeof(flow_keys) || err || retval != 1, "ipv6",

	      "err %d errno %d retval %d duration %d size %u/%lu\n",

	      err, errno, retval, duration, size, sizeof(flow_keys));

	CHECK_FLOW_KEYS("ipv6_flow_keys", flow_keys, pkt_v6_flow_keys);



	bpf_object__close(obj);

}

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

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

#include <test_progs.h>



#define MAX_CNT_RAWTP	10ull

#define MAX_STACK_RAWTP	100

struct get_stack_trace_t {

	int pid;

	int kern_stack_size;

	int user_stack_size;

	int user_stack_buildid_size;

	__u64 kern_stack[MAX_STACK_RAWTP];

	__u64 user_stack[MAX_STACK_RAWTP];

	struct bpf_stack_build_id user_stack_buildid[MAX_STACK_RAWTP];

};



static int get_stack_print_output(void *data, int size)

{

	bool good_kern_stack = false, good_user_stack = false;

	const char *nonjit_func = "___bpf_prog_run";

	struct get_stack_trace_t *e = data;

	int i, num_stack;

	static __u64 cnt;

	struct ksym *ks;



	cnt++;



	if (size < sizeof(struct get_stack_trace_t)) {

		__u64 *raw_data = data;

		bool found = false;



		num_stack = size / sizeof(__u64);

		/* If jit is enabled, we do not have a good way to

		 * verify the sanity of the kernel stack. So we

		 * just assume it is good if the stack is not empty.

		 * This could be improved in the future.

		 */

		if (jit_enabled) {

			found = num_stack > 0;

		} else {

			for (i = 0; i < num_stack; i++) {

				ks = ksym_search(raw_data[i]);

				if (strcmp(ks->name, nonjit_func) == 0) {

					found = true;

					break;

				}

			}

		}

		if (found) {

			good_kern_stack = true;

			good_user_stack = true;

		}

	} else {

		num_stack = e->kern_stack_size / sizeof(__u64);

		if (jit_enabled) {

			good_kern_stack = num_stack > 0;

		} else {

			for (i = 0; i < num_stack; i++) {

				ks = ksym_search(e->kern_stack[i]);

				if (strcmp(ks->name, nonjit_func) == 0) {

					good_kern_stack = true;

					break;

				}

			}

		}

		if (e->user_stack_size > 0 && e->user_stack_buildid_size > 0)

			good_user_stack = true;

	}

	if (!good_kern_stack || !good_user_stack)

		return LIBBPF_PERF_EVENT_ERROR;



	if (cnt == MAX_CNT_RAWTP)

		return LIBBPF_PERF_EVENT_DONE;



	return LIBBPF_PERF_EVENT_CONT;

}



void test_get_stack_raw_tp(void)

{

	const char *file = "./test_get_stack_rawtp.o";

	int i, efd, err, prog_fd, pmu_fd, perfmap_fd;

	struct perf_event_attr attr = {};

	struct timespec tv = {0, 10};

	__u32 key = 0, duration = 0;

	struct bpf_object *obj;



	err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT, &obj, &prog_fd);

	if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))

		return;



	efd = bpf_raw_tracepoint_open("sys_enter", prog_fd);

	if (CHECK(efd < 0, "raw_tp_open", "err %d errno %d\n", efd, errno))

		goto close_prog;



	perfmap_fd = bpf_find_map(__func__, obj, "perfmap");

	if (CHECK(perfmap_fd < 0, "bpf_find_map", "err %d errno %d\n",

		  perfmap_fd, errno))

		goto close_prog;



	err = load_kallsyms();

	if (CHECK(err < 0, "load_kallsyms", "err %d errno %d\n", err, errno))

		goto close_prog;



	attr.sample_type = PERF_SAMPLE_RAW;

	attr.type = PERF_TYPE_SOFTWARE;

	attr.config = PERF_COUNT_SW_BPF_OUTPUT;

	pmu_fd = syscall(__NR_perf_event_open, &attr, getpid()/*pid*/, -1/*cpu*/,

			 -1/*group_fd*/, 0);

	if (CHECK(pmu_fd < 0, "perf_event_open", "err %d errno %d\n", pmu_fd,

		  errno))

		goto close_prog;



	err = bpf_map_update_elem(perfmap_fd, &key, &pmu_fd, BPF_ANY);

	if (CHECK(err < 0, "bpf_map_update_elem", "err %d errno %d\n", err,

		  errno))

		goto close_prog;



	err = ioctl(pmu_fd, PERF_EVENT_IOC_ENABLE, 0);

	if (CHECK(err < 0, "ioctl PERF_EVENT_IOC_ENABLE", "err %d errno %d\n",

		  err, errno))

		goto close_prog;



	err = perf_event_mmap(pmu_fd);

	if (CHECK(err < 0, "perf_event_mmap", "err %d errno %d\n", err, errno))

		goto close_prog;



	/* trigger some syscall action */

	for (i = 0; i < MAX_CNT_RAWTP; i++)

		nanosleep(&tv, NULL);



	err = perf_event_poller(pmu_fd, get_stack_print_output);

	if (CHECK(err < 0, "perf_event_poller", "err %d errno %d\n", err, errno))

		goto close_prog;



	goto close_prog_noerr;

close_prog:

	error_cnt++;

close_prog_noerr:

	bpf_object__close(obj);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE