bpf: add selftest for stackmap with BPF_F_STACK_BUILD_ID (81f77fd0) · Commits · 戴 / test

tools/include/uapi/linux/bpf.h

+22 −0

Original line number	Diff line number	Diff line
		@@ -231,6 +231,28 @@ enum bpf_attach_type {
		#define BPF_F_RDONLY (1U << 3)
		#define BPF_F_WRONLY (1U << 4)

		/* Flag for stack_map, store build_id+offset instead of pointer */
		#define BPF_F_STACK_BUILD_ID (1U << 5)

		enum bpf_stack_build_id_status {
		/* user space need an empty entry to identify end of a trace */
		BPF_STACK_BUILD_ID_EMPTY = 0,
		/* with valid build_id and offset */
		BPF_STACK_BUILD_ID_VALID = 1,
		/* couldn't get build_id, fallback to ip */
		BPF_STACK_BUILD_ID_IP = 2,
		};

		#define BPF_BUILD_ID_SIZE 20
		struct bpf_stack_build_id {
		__s32 status;
		unsigned char build_id[BPF_BUILD_ID_SIZE];
		union {
		__u64 offset;
		__u64 ip;
		};
		};

		union bpf_attr {
		struct { /* anonymous struct used by BPF_MAP_CREATE command */
		__u32 map_type; /* one of enum bpf_map_type */

tools/testing/selftests/bpf/Makefile

+11 −1

Original line number	Diff line number	Diff line
		@@ -13,6 +13,14 @@ endif
		CFLAGS += -Wall -O2 -I$(APIDIR) -I$(LIBDIR) -I$(GENDIR) $(GENFLAGS) -I../../../include
		LDLIBS += -lcap -lelf -lrt -lpthread

		TEST_CUSTOM_PROGS = $(OUTPUT)/urandom_read
		all: $(TEST_CUSTOM_PROGS)

		$(TEST_CUSTOM_PROGS): urandom_read

		urandom_read: urandom_read.c
		$(CC) -o $(TEST_CUSTOM_PROGS) -static $<

		# 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_align test_verifier_log test_dev_cgroup test_tcpbpf_user
		@@ -21,7 +29,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test
		test_pkt_md_access.o test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o \
		sockmap_verdict_prog.o dev_cgroup.o sample_ret0.o test_tracepoint.o \
		test_l4lb_noinline.o test_xdp_noinline.o test_stacktrace_map.o \
		sample_map_ret0.o test_tcpbpf_kern.o
		sample_map_ret0.o test_tcpbpf_kern.o test_stacktrace_build_id.o

		# Order correspond to 'make run_tests' order
		TEST_PROGS := test_kmod.sh \
		@@ -74,3 +82,5 @@ $(OUTPUT)/%.o: %.c
		$(CLANG) $(CLANG_FLAGS) \
		-O2 -target bpf -emit-llvm -c $< -o - \| \
		$(LLC) -march=bpf -mcpu=$(CPU) -filetype=obj -o $@

		EXTRA_CLEAN := $(TEST_CUSTOM_PROGS)

tools/testing/selftests/bpf/test_progs.c

+163 −1

Original line number	Diff line number	Diff line
		@@ -841,7 +841,8 @@ static void test_tp_attach_query(void)
		static int compare_map_keys(int map1_fd, int map2_fd)
		{
		__u32 key, next_key;
		char val_buf[PERF_MAX_STACK_DEPTH * sizeof(__u64)];
		char val_buf[PERF_MAX_STACK_DEPTH *
		sizeof(struct bpf_stack_build_id)];
		int err;

		err = bpf_map_get_next_key(map1_fd, NULL, &key);
		@@ -964,6 +965,166 @@ out:
		return;
		}

		static int extract_build_id(char *build_id, size_t size)
		{
		FILE *fp;
		char *line = NULL;
		size_t len = 0;

		fp = popen("readelf -n ./urandom_read \| grep 'Build ID'", "r");
		if (fp == NULL)
		return -1;

		if (getline(&line, &len, fp) == -1)
		goto err;
		fclose(fp);

		if (len > size)
		len = size;
		memcpy(build_id, line, len);
		build_id[len] = '\0';
		return 0;
		err:
		fclose(fp);
		return -1;
		}

		static void test_stacktrace_build_id(void)
		{
		int control_map_fd, stackid_hmap_fd, stackmap_fd;
		const char *file = "./test_stacktrace_build_id.o";
		int bytes, efd, err, pmu_fd, prog_fd;
		struct perf_event_attr attr = {};
		__u32 key, previous_key, val, duration = 0;
		struct bpf_object *obj;
		char buf[256];
		int i, j;
		struct bpf_stack_build_id id_offs[PERF_MAX_STACK_DEPTH];
		int build_id_matches = 0;

		err = bpf_prog_load(file, BPF_PROG_TYPE_TRACEPOINT, &obj, &prog_fd);
		if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno))
		goto out;

		/* Get the ID for the sched/sched_switch tracepoint */
		snprintf(buf, sizeof(buf),
		"/sys/kernel/debug/tracing/events/random/urandom_read/id");
		efd = open(buf, O_RDONLY, 0);
		if (CHECK(efd < 0, "open", "err %d errno %d\n", efd, errno))
		goto close_prog;

		bytes = read(efd, buf, sizeof(buf));
		close(efd);
		if (CHECK(bytes <= 0 \|\| bytes >= sizeof(buf),
		"read", "bytes %d errno %d\n", bytes, errno))
		goto close_prog;

		/* Open the perf event and attach bpf progrram */
		attr.config = strtol(buf, NULL, 0);
		attr.type = PERF_TYPE_TRACEPOINT;
		attr.sample_type = PERF_SAMPLE_RAW \| PERF_SAMPLE_CALLCHAIN;
		attr.sample_period = 1;
		attr.wakeup_events = 1;
		pmu_fd = syscall(__NR_perf_event_open, &attr, -1 /* pid */,
		0 /* cpu 0 /, -1 / group id */,
		0 /* flags */);
		if (CHECK(pmu_fd < 0, "perf_event_open", "err %d errno %d\n",
		pmu_fd, errno))
		goto close_prog;

		err = ioctl(pmu_fd, PERF_EVENT_IOC_ENABLE, 0);
		if (CHECK(err, "perf_event_ioc_enable", "err %d errno %d\n",
		err, errno))
		goto close_pmu;

		err = ioctl(pmu_fd, PERF_EVENT_IOC_SET_BPF, prog_fd);
		if (CHECK(err, "perf_event_ioc_set_bpf", "err %d errno %d\n",
		err, errno))
		goto disable_pmu;

		/* find map fds */
		control_map_fd = bpf_find_map(__func__, obj, "control_map");
		if (CHECK(control_map_fd < 0, "bpf_find_map control_map",
		"err %d errno %d\n", err, errno))
		goto disable_pmu;

		stackid_hmap_fd = bpf_find_map(__func__, obj, "stackid_hmap");
		if (CHECK(stackid_hmap_fd < 0, "bpf_find_map stackid_hmap",
		"err %d errno %d\n", err, errno))
		goto disable_pmu;

		stackmap_fd = bpf_find_map(__func__, obj, "stackmap");
		if (CHECK(stackmap_fd < 0, "bpf_find_map stackmap", "err %d errno %d\n",
		err, errno))
		goto disable_pmu;

		assert(system("dd if=/dev/urandom of=/dev/zero count=4 2> /dev/null")
		== 0);
		assert(system("./urandom_read if=/dev/urandom of=/dev/zero count=4 2> /dev/null") == 0);
		/* disable stack trace collection */
		key = 0;
		val = 1;
		bpf_map_update_elem(control_map_fd, &key, &val, 0);

		/* for every element in stackid_hmap, we can find a corresponding one
		* in stackmap, and vise versa.
		*/
		err = compare_map_keys(stackid_hmap_fd, stackmap_fd);
		if (CHECK(err, "compare_map_keys stackid_hmap vs. stackmap",
		"err %d errno %d\n", err, errno))
		goto disable_pmu;

		err = compare_map_keys(stackmap_fd, stackid_hmap_fd);
		if (CHECK(err, "compare_map_keys stackmap vs. stackid_hmap",
		"err %d errno %d\n", err, errno))
		goto disable_pmu;

		err = extract_build_id(buf, 256);

		if (CHECK(err, "get build_id with readelf",
		"err %d errno %d\n", err, errno))
		goto disable_pmu;

		err = bpf_map_get_next_key(stackmap_fd, NULL, &key);
		if (CHECK(err, "get_next_key from stackmap",
		"err %d, errno %d\n", err, errno))
		goto disable_pmu;

		do {
		char build_id[64];

		err = bpf_map_lookup_elem(stackmap_fd, &key, id_offs);
		if (CHECK(err, "lookup_elem from stackmap",
		"err %d, errno %d\n", err, errno))
		goto disable_pmu;
		for (i = 0; i < PERF_MAX_STACK_DEPTH; ++i)
		if (id_offs[i].status == BPF_STACK_BUILD_ID_VALID &&
		id_offs[i].offset != 0) {
		for (j = 0; j < 20; ++j)
		sprintf(build_id + 2 * j, "%02x",
		id_offs[i].build_id[j] & 0xff);
		if (strstr(buf, build_id) != NULL)
		build_id_matches = 1;
		}
		previous_key = key;
		} while (bpf_map_get_next_key(stackmap_fd, &previous_key, &key) == 0);

		CHECK(build_id_matches < 1, "build id match",
		"Didn't find expected build ID from the map");

		disable_pmu:
		ioctl(pmu_fd, PERF_EVENT_IOC_DISABLE);

		close_pmu:
		close(pmu_fd);

		close_prog:
		bpf_object__close(obj);

		out:
		return;
		}

		int main(void)
		{
		test_pkt_access();
		@@ -976,6 +1137,7 @@ int main(void)
		test_obj_name();
		test_tp_attach_query();
		test_stacktrace_map();
		test_stacktrace_build_id();

		printf("Summary: %d PASSED, %d FAILED\n", pass_cnt, error_cnt);
		return error_cnt ? EXIT_FAILURE : EXIT_SUCCESS;

tools/testing/selftests/bpf/test_stacktrace_build_id.c

0 → 100644

+60 −0

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

		#include <linux/bpf.h>
		#include "bpf_helpers.h"

		#ifndef PERF_MAX_STACK_DEPTH
		#define PERF_MAX_STACK_DEPTH 127
		#endif

		struct bpf_map_def SEC("maps") control_map = {
		.type = BPF_MAP_TYPE_ARRAY,
		.key_size = sizeof(__u32),
		.value_size = sizeof(__u32),
		.max_entries = 1,
		};

		struct bpf_map_def SEC("maps") stackid_hmap = {
		.type = BPF_MAP_TYPE_HASH,
		.key_size = sizeof(__u32),
		.value_size = sizeof(__u32),
		.max_entries = 10000,
		};

		struct bpf_map_def SEC("maps") stackmap = {
		.type = BPF_MAP_TYPE_STACK_TRACE,
		.key_size = sizeof(__u32),
		.value_size = sizeof(struct bpf_stack_build_id)
		* PERF_MAX_STACK_DEPTH,
		.max_entries = 128,
		.map_flags = BPF_F_STACK_BUILD_ID,
		};

		/* taken from /sys/kernel/debug/tracing/events/random/urandom_read/format */
		struct random_urandom_args {
		unsigned long long pad;
		int got_bits;
		int pool_left;
		int input_left;
		};

		SEC("tracepoint/random/urandom_read")
		int oncpu(struct random_urandom_args *args)
		{
		__u32 key = 0, val = 0, *value_p;

		value_p = bpf_map_lookup_elem(&control_map, &key);
		if (value_p && *value_p)
		return 0; /* skip if non-zero value_p /

		/* The size of stackmap and stackid_hmap should be the same */
		key = bpf_get_stackid(args, &stackmap, BPF_F_USER_STACK);
		if ((int)key >= 0)
		bpf_map_update_elem(&stackid_hmap, &key, &val, 0);

		return 0;
		}

		char _license[] SEC("license") = "GPL";
		__u32 _version SEC("version") = 1; /* ignored by tracepoints, required by libbpf.a */

tools/testing/selftests/bpf/urandom_read.c

0 → 100644

+22 −0

Original line number	Diff line number	Diff line
		#include <stdio.h>
		#include <unistd.h>
		#include <sys/types.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <stdlib.h>

		#define BUF_SIZE 256
		int main(void)
		{
		int fd = open("/dev/urandom", O_RDONLY);
		int i;
		char buf[BUF_SIZE];

		if (fd < 0)
		return 1;
		for (i = 0; i < 4; ++i)
		read(fd, buf, BUF_SIZE);

		close(fd);
		return 0;
		}

Admin message