Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 81f77fd0 authored by Song Liu's avatar Song Liu Committed by Daniel Borkmann
Browse files

bpf: add selftest for stackmap with BPF_F_STACK_BUILD_ID 



test_stacktrace_build_id() is added. It accesses tracepoint urandom_read
with "dd" and "urandom_read" and gathers stack traces. Then it reads the
stack traces from the stackmap.

urandom_read is a statically link binary that reads from /dev/urandom.
test_stacktrace_build_id() calls readelf to read build ID of urandom_read
and compares it with build ID from the stackmap.

Signed-off-by: default avatarSong Liu <songliubraving@fb.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parent 615755a7

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 @@ static void test_stacktrace_map() 
	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;

}