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

Commit cd8b8928 authored by Martin KaFai Lau's avatar Martin KaFai Lau Committed by Daniel Borkmann
Browse files

bpf: btf: Tests for BPF_OBJ_GET_INFO_BY_FD and BPF_BTF_GET_FD_BY_ID 



This patch adds test for BPF_BTF_GET_FD_BY_ID and the new
btf_id/btf_key_id/btf_value_id in the "struct bpf_map_info".

It also modifies the existing BPF_OBJ_GET_INFO_BY_FD test
to reflect the new "struct bpf_btf_info".

Signed-off-by: default avatarMartin KaFai Lau <kafai@fb.com>
Acked-by: default avatarAlexei Starovoitov <ast@fb.com>
Acked-by: default avatarSong Liu <songliubraving@fb.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parent 7a01f6a3

tools/lib/bpf/bpf.c

+10 −0
Original line number Diff line number Diff line
@@ -458,6 +458,16 @@ int bpf_map_get_fd_by_id(__u32 id) 
	return sys_bpf(BPF_MAP_GET_FD_BY_ID, &attr, sizeof(attr));

}



int bpf_btf_get_fd_by_id(__u32 id)

{

	union bpf_attr attr;



	bzero(&attr, sizeof(attr));

	attr.btf_id = id;



	return sys_bpf(BPF_BTF_GET_FD_BY_ID, &attr, sizeof(attr));

}



int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len)

{

	union bpf_attr attr;

tools/lib/bpf/bpf.h

+1 −0
Original line number Diff line number Diff line
@@ -98,6 +98,7 @@ int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id); 
int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);

int bpf_prog_get_fd_by_id(__u32 id);

int bpf_map_get_fd_by_id(__u32 id);

int bpf_btf_get_fd_by_id(__u32 id);

int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len);

int bpf_prog_query(int target_fd, enum bpf_attach_type type, __u32 query_flags,

		   __u32 *attach_flags, __u32 *prog_ids, __u32 *prog_cnt);

tools/testing/selftests/bpf/test_btf.c

+276 −13
Original line number Diff line number Diff line
@@ -1047,9 +1047,13 @@ struct btf_get_info_test { 
	const char *str_sec;

	__u32 raw_types[MAX_NR_RAW_TYPES];

	__u32 str_sec_size;

	int info_size_delta;

	int btf_size_delta;

	int (*special_test)(unsigned int test_num);

};



static int test_big_btf_info(unsigned int test_num);

static int test_btf_id(unsigned int test_num);



const struct btf_get_info_test get_info_tests[] = {

{

	.descr = "== raw_btf_size+1",
@@ -1060,7 +1064,7 @@ const struct btf_get_info_test get_info_tests[] = { 
	},

	.str_sec = "",

	.str_sec_size = sizeof(""),

	.info_size_delta = 1,

	.btf_size_delta = 1,

},

{

	.descr = "== raw_btf_size-3",
@@ -1071,20 +1075,274 @@ const struct btf_get_info_test get_info_tests[] = { 
	},

	.str_sec = "",

	.str_sec_size = sizeof(""),

	.info_size_delta = -3,

	.btf_size_delta = -3,

},

{

	.descr = "Large bpf_btf_info",

	.raw_types = {

		/* int */				/* [1] */

		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),

		BTF_END_RAW,

	},

	.str_sec = "",

	.str_sec_size = sizeof(""),

	.special_test = test_big_btf_info,

},

{

	.descr = "BTF ID",

	.raw_types = {

		/* int */				/* [1] */

		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),

		/* unsigned int */			/* [2] */

		BTF_TYPE_INT_ENC(0, 0, 0, 32, 4),

		BTF_END_RAW,

	},

	.str_sec = "",

	.str_sec_size = sizeof(""),

	.special_test = test_btf_id,

},

};



static inline __u64 ptr_to_u64(const void *ptr)

{

	return (__u64)(unsigned long)ptr;

}



static int test_big_btf_info(unsigned int test_num)

{

	const struct btf_get_info_test *test = &get_info_tests[test_num - 1];

	uint8_t *raw_btf = NULL, *user_btf = NULL;

	unsigned int raw_btf_size;

	struct {

		struct bpf_btf_info info;

		uint64_t garbage;

	} info_garbage;

	struct bpf_btf_info *info;

	int btf_fd = -1, err;

	uint32_t info_len;



	raw_btf = btf_raw_create(&hdr_tmpl,

				 test->raw_types,

				 test->str_sec,

				 test->str_sec_size,

				 &raw_btf_size);



	if (!raw_btf)

		return -1;



	*btf_log_buf = '\0';



	user_btf = malloc(raw_btf_size);

	if (CHECK(!user_btf, "!user_btf")) {

		err = -1;

		goto done;

	}



	btf_fd = bpf_load_btf(raw_btf, raw_btf_size,

			      btf_log_buf, BTF_LOG_BUF_SIZE,

			      args.always_log);

	if (CHECK(btf_fd == -1, "errno:%d", errno)) {

		err = -1;

		goto done;

	}



	/*

	 * GET_INFO should error out if the userspace info

	 * has non zero tailing bytes.

	 */

	info = &info_garbage.info;

	memset(info, 0, sizeof(*info));

	info_garbage.garbage = 0xdeadbeef;

	info_len = sizeof(info_garbage);

	info->btf = ptr_to_u64(user_btf);

	info->btf_size = raw_btf_size;



	err = bpf_obj_get_info_by_fd(btf_fd, info, &info_len);

	if (CHECK(!err, "!err")) {

		err = -1;

		goto done;

	}



	/*

	 * GET_INFO should succeed even info_len is larger than

	 * the kernel supported as long as tailing bytes are zero.

	 * The kernel supported info len should also be returned

	 * to userspace.

	 */

	info_garbage.garbage = 0;

	err = bpf_obj_get_info_by_fd(btf_fd, info, &info_len);

	if (CHECK(err || info_len != sizeof(*info),

		  "err:%d errno:%d info_len:%u sizeof(*info):%lu",

		  err, errno, info_len, sizeof(*info))) {

		err = -1;

		goto done;

	}



	fprintf(stderr, "OK");



done:

	if (*btf_log_buf && (err || args.always_log))

		fprintf(stderr, "\n%s", btf_log_buf);



	free(raw_btf);

	free(user_btf);



	if (btf_fd != -1)

		close(btf_fd);



	return err;

}



static int test_btf_id(unsigned int test_num)

{

	const struct btf_get_info_test *test = &get_info_tests[test_num - 1];

	struct bpf_create_map_attr create_attr = {};

	uint8_t *raw_btf = NULL, *user_btf[2] = {};

	int btf_fd[2] = {-1, -1}, map_fd = -1;

	struct bpf_map_info map_info = {};

	struct bpf_btf_info info[2] = {};

	unsigned int raw_btf_size;

	uint32_t info_len;

	int err, i, ret;



	raw_btf = btf_raw_create(&hdr_tmpl,

				 test->raw_types,

				 test->str_sec,

				 test->str_sec_size,

				 &raw_btf_size);



	if (!raw_btf)

		return -1;



	*btf_log_buf = '\0';



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

		user_btf[i] = malloc(raw_btf_size);

		if (CHECK(!user_btf[i], "!user_btf[%d]", i)) {

			err = -1;

			goto done;

		}

		info[i].btf = ptr_to_u64(user_btf[i]);

		info[i].btf_size = raw_btf_size;

	}



	btf_fd[0] = bpf_load_btf(raw_btf, raw_btf_size,

				 btf_log_buf, BTF_LOG_BUF_SIZE,

				 args.always_log);

	if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {

		err = -1;

		goto done;

	}



	/* Test BPF_OBJ_GET_INFO_BY_ID on btf_id */

	info_len = sizeof(info[0]);

	err = bpf_obj_get_info_by_fd(btf_fd[0], &info[0], &info_len);

	if (CHECK(err, "errno:%d", errno)) {

		err = -1;

		goto done;

	}



	btf_fd[1] = bpf_btf_get_fd_by_id(info[0].id);

	if (CHECK(btf_fd[1] == -1, "errno:%d", errno)) {

		err = -1;

		goto done;

	}



	ret = 0;

	err = bpf_obj_get_info_by_fd(btf_fd[1], &info[1], &info_len);

	if (CHECK(err || info[0].id != info[1].id ||

		  info[0].btf_size != info[1].btf_size ||

		  (ret = memcmp(user_btf[0], user_btf[1], info[0].btf_size)),

		  "err:%d errno:%d id0:%u id1:%u btf_size0:%u btf_size1:%u memcmp:%d",

		  err, errno, info[0].id, info[1].id,

		  info[0].btf_size, info[1].btf_size, ret)) {

		err = -1;

		goto done;

	}



	/* Test btf members in struct bpf_map_info */

	create_attr.name = "test_btf_id";

	create_attr.map_type = BPF_MAP_TYPE_ARRAY;

	create_attr.key_size = sizeof(int);

	create_attr.value_size = sizeof(unsigned int);

	create_attr.max_entries = 4;

	create_attr.btf_fd = btf_fd[0];

	create_attr.btf_key_id = 1;

	create_attr.btf_value_id = 2;



	map_fd = bpf_create_map_xattr(&create_attr);

	if (CHECK(map_fd == -1, "errno:%d", errno)) {

		err = -1;

		goto done;

	}



	info_len = sizeof(map_info);

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

	if (CHECK(err || map_info.btf_id != info[0].id ||

		  map_info.btf_key_id != 1 || map_info.btf_value_id != 2,

		  "err:%d errno:%d info.id:%u btf_id:%u btf_key_id:%u btf_value_id:%u",

		  err, errno, info[0].id, map_info.btf_id, map_info.btf_key_id,

		  map_info.btf_value_id)) {

		err = -1;

		goto done;

	}



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

		close(btf_fd[i]);

		btf_fd[i] = -1;

	}



	/* Test BTF ID is removed from the kernel */

	btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);

	if (CHECK(btf_fd[0] == -1, "errno:%d", errno)) {

		err = -1;

		goto done;

	}

	close(btf_fd[0]);

	btf_fd[0] = -1;



	/* The map holds the last ref to BTF and its btf_id */

	close(map_fd);

	map_fd = -1;

	btf_fd[0] = bpf_btf_get_fd_by_id(map_info.btf_id);

	if (CHECK(btf_fd[0] != -1, "BTF lingers")) {

		err = -1;

		goto done;

	}



	fprintf(stderr, "OK");



done:

	if (*btf_log_buf && (err || args.always_log))

		fprintf(stderr, "\n%s", btf_log_buf);



	free(raw_btf);

	if (map_fd != -1)

		close(map_fd);

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

		free(user_btf[i]);

		if (btf_fd[i] != -1)

			close(btf_fd[i]);

	}



	return err;

}



static int do_test_get_info(unsigned int test_num)

{

	const struct btf_get_info_test *test = &get_info_tests[test_num - 1];

	unsigned int raw_btf_size, user_btf_size, expected_nbytes;

	uint8_t *raw_btf = NULL, *user_btf = NULL;

	int btf_fd = -1, err;

	struct bpf_btf_info info = {};

	int btf_fd = -1, err, ret;

	uint32_t info_len;



	fprintf(stderr, "BTF GET_INFO_BY_ID test[%u] (%s): ",

	fprintf(stderr, "BTF GET_INFO test[%u] (%s): ",

		test_num, test->descr);



	if (test->special_test)

		return test->special_test(test_num);



	raw_btf = btf_raw_create(&hdr_tmpl,

				 test->raw_types,

				 test->str_sec,
@@ -1110,19 +1368,24 @@ static int do_test_get_info(unsigned int test_num) 
		goto done;

	}



	user_btf_size = (int)raw_btf_size + test->info_size_delta;

	user_btf_size = (int)raw_btf_size + test->btf_size_delta;

	expected_nbytes = min(raw_btf_size, user_btf_size);

	if (raw_btf_size > expected_nbytes)

		memset(user_btf + expected_nbytes, 0xff,

		       raw_btf_size - expected_nbytes);



	err = bpf_obj_get_info_by_fd(btf_fd, user_btf, &user_btf_size);

	if (CHECK(err || user_btf_size != raw_btf_size ||

		  memcmp(raw_btf, user_btf, expected_nbytes),

		  "err:%d(errno:%d) raw_btf_size:%u user_btf_size:%u expected_nbytes:%u memcmp:%d",

		  err, errno,

		  raw_btf_size, user_btf_size, expected_nbytes,

		  memcmp(raw_btf, user_btf, expected_nbytes))) {

	info_len = sizeof(info);

	info.btf = ptr_to_u64(user_btf);

	info.btf_size = user_btf_size;



	ret = 0;

	err = bpf_obj_get_info_by_fd(btf_fd, &info, &info_len);

	if (CHECK(err || !info.id || info_len != sizeof(info) ||

		  info.btf_size != raw_btf_size ||

		  (ret = memcmp(raw_btf, user_btf, expected_nbytes)),

		  "err:%d errno:%d info.id:%u info_len:%u sizeof(info):%lu raw_btf_size:%u info.btf_size:%u expected_nbytes:%u memcmp:%d",

		  err, errno, info.id, info_len, sizeof(info),

		  raw_btf_size, info.btf_size, expected_nbytes, ret)) {

		err = -1;

		goto done;

	}