selftests/btf: add initial BTF dedup tests (9c651127) · Commits · 戴 / test

tools/lib/bpf/btf.c

+12 −0

Original line number	Diff line number	Diff line
		@@ -237,6 +237,11 @@ static int btf_parse_type_sec(struct btf *btf)
		return 0;
		}

		__u32 btf__get_nr_types(const struct btf *btf)
		{
		return btf->nr_types;
		}

		const struct btf_type btf__type_by_id(const struct btf btf, __u32 type_id)
		{
		if (type_id > btf->nr_types)
		@@ -427,6 +432,13 @@ int btf__fd(const struct btf *btf)
		return btf->fd;
		}

		void btf__get_strings(const struct btf btf, const char *strings,
		__u32 *str_len)
		{
		*strings = btf->strings;
		*str_len = btf->hdr->str_len;
		}

		const char btf__name_by_offset(const struct btf btf, __u32 offset)
		{
		if (offset < btf->hdr->str_len)

tools/lib/bpf/btf.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -59,11 +59,14 @@ LIBBPF_API void btf__free(struct btf *btf);
		LIBBPF_API struct btf btf__new(__u8 data, __u32 size);
		LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,
		const char *type_name);
		LIBBPF_API __u32 btf__get_nr_types(const struct btf *btf);
		LIBBPF_API const struct btf_type btf__type_by_id(const struct btf btf,
		__u32 id);
		LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);
		LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id);
		LIBBPF_API int btf__fd(const struct btf *btf);
		LIBBPF_API void btf__get_strings(const struct btf btf, const char *strings,
		__u32 *str_len);
		LIBBPF_API const char btf__name_by_offset(const struct btf btf, __u32 offset);
		LIBBPF_API int btf__get_from_id(__u32 id, struct btf **btf);
		LIBBPF_API int btf__get_map_kv_tids(const struct btf btf, char map_name,

tools/lib/bpf/libbpf.map

+2 −0

Original line number	Diff line number	Diff line
		@@ -135,6 +135,8 @@ LIBBPF_0.0.2 {
		bpf_get_link_xdp_id;
		btf__dedup;
		btf__get_map_kv_tids;
		btf__get_nr_types;
		btf__get_strings;
		btf_ext__free;
		btf_ext__func_info_rec_size;
		btf_ext__line_info_rec_size;

tools/testing/selftests/bpf/test_btf.c

+520 −15

Original line number	Diff line number	Diff line
		@@ -70,12 +70,21 @@ static int __base_pr(enum libbpf_print_level level __attribute__((unused)),
		BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), sz), \
		BTF_INT_ENC(encoding, bits_offset, bits)

		#define BTF_FWD_ENC(name, kind_flag) \
		BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FWD, kind_flag, 0), 0)

		#define BTF_ARRAY_ENC(type, index_type, nr_elems) \
		(type), (index_type), (nr_elems)
		#define BTF_TYPE_ARRAY_ENC(type, index_type, nr_elems) \
		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_ARRAY, 0, 0), 0), \
		BTF_ARRAY_ENC(type, index_type, nr_elems)

		#define BTF_STRUCT_ENC(name, nr_elems, sz) \
		BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_STRUCT, 0, nr_elems), sz)

		#define BTF_UNION_ENC(name, nr_elems, sz) \
		BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_UNION, 0, nr_elems), sz)

		#define BTF_MEMBER_ENC(name, type, bits_offset) \
		(name), (type), (bits_offset)
		#define BTF_ENUM_ENC(name, val) (name), (val)
		@@ -91,6 +100,12 @@ static int __base_pr(enum libbpf_print_level level __attribute__((unused)),
		#define BTF_CONST_ENC(type) \
		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_CONST, 0, 0), type)

		#define BTF_VOLATILE_ENC(type) \
		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_VOLATILE, 0, 0), type)

		#define BTF_RESTRICT_ENC(type) \
		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_RESTRICT, 0, 0), type)

		#define BTF_FUNC_PROTO_ENC(ret_type, nargs) \
		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, nargs), ret_type)

		@@ -103,6 +118,10 @@ static int __base_pr(enum libbpf_print_level level __attribute__((unused)),
		#define BTF_END_RAW 0xdeadbeef
		#define NAME_TBD 0xdeadb33f

		#define NAME_NTH(N) (0xffff0000 \| N)
		#define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xffff0000)
		#define GET_NAME_NTH_IDX(X) (X & 0x0000ffff)

		#define MAX_NR_RAW_U32 1024
		#define BTF_LOG_BUF_SIZE 65535

		@@ -111,12 +130,14 @@ static struct args {
		unsigned int file_test_num;
		unsigned int get_info_test_num;
		unsigned int info_raw_test_num;
		unsigned int dedup_test_num;
		bool raw_test;
		bool file_test;
		bool get_info_test;
		bool pprint_test;
		bool always_log;
		bool info_raw_test;
		bool dedup_test;
		} args;

		static char btf_log_buf[BTF_LOG_BUF_SIZE];
		@@ -2827,11 +2848,13 @@ static void btf_raw_create(const struct btf_header hdr,
		const char **ret_next_str)
		{
		const char next_str = str, end_str = str + str_sec_size;
		const char strs_idx = NULL, tmp_strs_idx;
		int strs_cap = 0, strs_cnt = 0, next_str_idx = 0;
		unsigned int size_needed, offset;
		struct btf_header *ret_hdr;
		int i, type_sec_size;
		int i, type_sec_size, err = 0;
		uint32_t *ret_types;
		void *raw_btf;
		void *raw_btf = NULL;

		type_sec_size = get_raw_sec_size(raw_types);
		if (CHECK(type_sec_size < 0, "Cannot get nr_raw_types"))
		@@ -2846,17 +2869,44 @@ static void btf_raw_create(const struct btf_header hdr,
		memcpy(raw_btf, hdr, sizeof(*hdr));
		offset = sizeof(*hdr);

		/* Index strings */
		while ((next_str = get_next_str(next_str, end_str))) {
		if (strs_cnt == strs_cap) {
		strs_cap += max(16, strs_cap / 2);
		tmp_strs_idx = realloc(strs_idx,
		sizeof(strs_idx) strs_cap);
		if (CHECK(!tmp_strs_idx,
		"Cannot allocate memory for strs_idx")) {
		err = -1;
		goto done;
		}
		strs_idx = tmp_strs_idx;
		}
		strs_idx[strs_cnt++] = next_str;
		next_str += strlen(next_str);
		}

		/* Copy type section */
		ret_types = raw_btf + offset;
		for (i = 0; i < type_sec_size / sizeof(raw_types[0]); i++) {
		if (raw_types[i] == NAME_TBD) {
		next_str = get_next_str(next_str, end_str);
		if (CHECK(!next_str, "Error in getting next_str")) {
		free(raw_btf);
		return NULL;
		if (CHECK(next_str_idx == strs_cnt,
		"Error in getting next_str #%d",
		next_str_idx)) {
		err = -1;
		goto done;
		}
		ret_types[i] = next_str - str;
		next_str += strlen(next_str);
		ret_types[i] = strs_idx[next_str_idx++] - str;
		} else if (IS_NAME_NTH(raw_types[i])) {
		int idx = GET_NAME_NTH_IDX(raw_types[i]);

		if (CHECK(idx <= 0 \|\| idx > strs_cnt,
		"Error getting string #%d, strs_cnt:%d",
		idx, strs_cnt)) {
		err = -1;
		goto done;
		}
		ret_types[i] = strs_idx[idx-1] - str;
		} else {
		ret_types[i] = raw_types[i];
		}
		@@ -2873,8 +2923,17 @@ static void btf_raw_create(const struct btf_header hdr,

		*btf_size = size_needed;
		if (ret_next_str)
		*ret_next_str = next_str;
		*ret_next_str =
		next_str_idx < strs_cnt ? strs_idx[next_str_idx] : NULL;

		done:
		if (err) {
		if (raw_btf)
		free(raw_btf);
		if (strs_idx)
		free(strs_idx);
		return NULL;
		}
		return raw_btf;
		}

		@@ -5543,20 +5602,450 @@ static int test_info_raw(void)
		return err;
		}

		struct btf_raw_data {
		__u32 raw_types[MAX_NR_RAW_U32];
		const char *str_sec;
		__u32 str_sec_size;
		};

		struct btf_dedup_test {
		const char *descr;
		struct btf_raw_data input;
		struct btf_raw_data expect;
		struct btf_dedup_opts opts;
		};

		const struct btf_dedup_test dedup_tests[] = {

		{
		.descr = "dedup: unused strings filtering",
		.input = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 4),
		BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 64, 8),
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0unused\0int\0foo\0bar\0long"),
		},
		.expect = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
		BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0int\0long"),
		},
		.opts = {
		.dont_resolve_fwds = false,
		},
		},
		{
		.descr = "dedup: strings deduplication",
		.input = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
		BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
		BTF_TYPE_INT_ENC(NAME_NTH(3), BTF_INT_SIGNED, 0, 32, 4),
		BTF_TYPE_INT_ENC(NAME_NTH(4), BTF_INT_SIGNED, 0, 64, 8),
		BTF_TYPE_INT_ENC(NAME_NTH(5), BTF_INT_SIGNED, 0, 32, 4),
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0int\0long int\0int\0long int\0int"),
		},
		.expect = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
		BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 64, 8),
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0int\0long int"),
		},
		.opts = {
		.dont_resolve_fwds = false,
		},
		},
		{
		.descr = "dedup: struct example #1",
		/*
		* struct s {
		* struct s *next;
		* const int *a;
		* int b[16];
		* int c;
		* }
		*/
		.input = {
		.raw_types = {
		/* int */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [1] */
		/* int[16] */
		BTF_TYPE_ARRAY_ENC(1, 1, 16), /* [2] */
		/* struct s { */
		BTF_STRUCT_ENC(NAME_NTH(2), 4, 84), /* [3] */
		BTF_MEMBER_ENC(NAME_NTH(3), 4, 0), /* struct s next; /
		BTF_MEMBER_ENC(NAME_NTH(4), 5, 64), /* const int a; /
		BTF_MEMBER_ENC(NAME_NTH(5), 2, 128), /* int b[16]; */
		BTF_MEMBER_ENC(NAME_NTH(6), 1, 640), /* int c; */
		/* ptr -> [3] struct s */
		BTF_PTR_ENC(3), /* [4] */
		/* ptr -> [6] const int */
		BTF_PTR_ENC(6), /* [5] */
		/* const -> [1] int */
		BTF_CONST_ENC(1), /* [6] */

		/* full copy of the above */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [7] */
		BTF_TYPE_ARRAY_ENC(7, 7, 16), /* [8] */
		BTF_STRUCT_ENC(NAME_NTH(2), 4, 84), /* [9] */
		BTF_MEMBER_ENC(NAME_NTH(3), 10, 0),
		BTF_MEMBER_ENC(NAME_NTH(4), 11, 64),
		BTF_MEMBER_ENC(NAME_NTH(5), 8, 128),
		BTF_MEMBER_ENC(NAME_NTH(6), 7, 640),
		BTF_PTR_ENC(9), /* [10] */
		BTF_PTR_ENC(12), /* [11] */
		BTF_CONST_ENC(7), /* [12] */
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0int\0s\0next\0a\0b\0c\0"),
		},
		.expect = {
		.raw_types = {
		/* int */
		BTF_TYPE_INT_ENC(NAME_NTH(4), BTF_INT_SIGNED, 0, 32, 4), /* [1] */
		/* int[16] */
		BTF_TYPE_ARRAY_ENC(1, 1, 16), /* [2] */
		/* struct s { */
		BTF_STRUCT_ENC(NAME_NTH(6), 4, 84), /* [3] */
		BTF_MEMBER_ENC(NAME_NTH(5), 4, 0), /* struct s next; /
		BTF_MEMBER_ENC(NAME_NTH(1), 5, 64), /* const int a; /
		BTF_MEMBER_ENC(NAME_NTH(2), 2, 128), /* int b[16]; */
		BTF_MEMBER_ENC(NAME_NTH(3), 1, 640), /* int c; */
		/* ptr -> [3] struct s */
		BTF_PTR_ENC(3), /* [4] */
		/* ptr -> [6] const int */
		BTF_PTR_ENC(6), /* [5] */
		/* const -> [1] int */
		BTF_CONST_ENC(1), /* [6] */
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0a\0b\0c\0int\0next\0s"),
		},
		.opts = {
		.dont_resolve_fwds = false,
		},
		},
		{
		.descr = "dedup: all possible kinds (no duplicates)",
		.input = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 8), /* [1] int */
		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 4), /* [2] enum */
		BTF_ENUM_ENC(NAME_TBD, 0),
		BTF_ENUM_ENC(NAME_TBD, 1),
		BTF_FWD_ENC(NAME_TBD, 1 /* union kind_flag /), / [3] fwd */
		BTF_TYPE_ARRAY_ENC(2, 1, 7), /* [4] array */
		BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [5] struct */
		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
		BTF_UNION_ENC(NAME_TBD, 1, 4), /* [6] union */
		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
		BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [7] typedef */
		BTF_PTR_ENC(0), /* [8] ptr */
		BTF_CONST_ENC(8), /* [9] const */
		BTF_VOLATILE_ENC(8), /* [10] volatile */
		BTF_RESTRICT_ENC(8), /* [11] restrict */
		BTF_FUNC_PROTO_ENC(1, 2), /* [12] func_proto */
		BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
		BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
		BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M"),
		},
		.expect = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_TBD, BTF_INT_SIGNED, 0, 32, 8), /* [1] int */
		BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_ENUM, 0, 2), 4), /* [2] enum */
		BTF_ENUM_ENC(NAME_TBD, 0),
		BTF_ENUM_ENC(NAME_TBD, 1),
		BTF_FWD_ENC(NAME_TBD, 1 /* union kind_flag /), / [3] fwd */
		BTF_TYPE_ARRAY_ENC(2, 1, 7), /* [4] array */
		BTF_STRUCT_ENC(NAME_TBD, 1, 4), /* [5] struct */
		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
		BTF_UNION_ENC(NAME_TBD, 1, 4), /* [6] union */
		BTF_MEMBER_ENC(NAME_TBD, 1, 0),
		BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [7] typedef */
		BTF_PTR_ENC(0), /* [8] ptr */
		BTF_CONST_ENC(8), /* [9] const */
		BTF_VOLATILE_ENC(8), /* [10] volatile */
		BTF_RESTRICT_ENC(8), /* [11] restrict */
		BTF_FUNC_PROTO_ENC(1, 2), /* [12] func_proto */
		BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
		BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
		BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M"),
		},
		.opts = {
		.dont_resolve_fwds = false,
		},
		},
		{
		.descr = "dedup: no int duplicates",
		.input = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 8),
		/* different name */
		BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 8),
		/* different encoding */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_CHAR, 0, 32, 8),
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_BOOL, 0, 32, 8),
		/* different bit offset */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 8, 32, 8),
		/* different bit size */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 27, 8),
		/* different byte size */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0int\0some other int"),
		},
		.expect = {
		.raw_types = {
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 8),
		/* different name */
		BTF_TYPE_INT_ENC(NAME_NTH(2), BTF_INT_SIGNED, 0, 32, 8),
		/* different encoding */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_CHAR, 0, 32, 8),
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_BOOL, 0, 32, 8),
		/* different bit offset */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 8, 32, 8),
		/* different bit size */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 27, 8),
		/* different byte size */
		BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4),
		BTF_END_RAW,
		},
		BTF_STR_SEC("\0int\0some other int"),
		},
		.opts = {
		.dont_resolve_fwds = false,
		},
		},

		};

		static int btf_type_size(const struct btf_type *t)
		{
		int base_size = sizeof(struct btf_type);
		__u16 vlen = BTF_INFO_VLEN(t->info);
		__u16 kind = BTF_INFO_KIND(t->info);

		switch (kind) {
		case BTF_KIND_FWD:
		case BTF_KIND_CONST:
		case BTF_KIND_VOLATILE:
		case BTF_KIND_RESTRICT:
		case BTF_KIND_PTR:
		case BTF_KIND_TYPEDEF:
		case BTF_KIND_FUNC:
		return base_size;
		case BTF_KIND_INT:
		return base_size + sizeof(__u32);
		case BTF_KIND_ENUM:
		return base_size + vlen * sizeof(struct btf_enum);
		case BTF_KIND_ARRAY:
		return base_size + sizeof(struct btf_array);
		case BTF_KIND_STRUCT:
		case BTF_KIND_UNION:
		return base_size + vlen * sizeof(struct btf_member);
		case BTF_KIND_FUNC_PROTO:
		return base_size + vlen * sizeof(struct btf_param);
		default:
		fprintf(stderr, "Unsupported BTF_KIND:%u\n", kind);
		return -EINVAL;
		}
		}

		static void dump_btf_strings(const char *strs, __u32 len)
		{
		const char *cur = strs;
		int i = 0;

		while (cur < strs + len) {
		fprintf(stderr, "string #%d: '%s'\n", i, cur);
		cur += strlen(cur) + 1;
		i++;
		}
		}

		static int do_test_dedup(unsigned int test_num)
		{
		const struct btf_dedup_test *test = &dedup_tests[test_num - 1];
		int err = 0, i;
		__u32 test_nr_types, expect_nr_types, test_str_len, expect_str_len;
		void *raw_btf;
		unsigned int raw_btf_size;
		struct btf test_btf = NULL, expect_btf = NULL;
		const char ret_test_next_str, ret_expect_next_str;
		const char test_strs, expect_strs;
		const char test_str_cur, test_str_end;
		const char expect_str_cur, expect_str_end;

		fprintf(stderr, "BTF dedup test[%u] (%s):", test_num, test->descr);

		raw_btf = btf_raw_create(&hdr_tmpl, test->input.raw_types,
		test->input.str_sec, test->input.str_sec_size,
		&raw_btf_size, &ret_test_next_str);
		if (!raw_btf)
		return -1;
		test_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
		free(raw_btf);
		if (CHECK(IS_ERR(test_btf), "invalid test_btf errno:%ld",
		PTR_ERR(test_btf))) {
		err = -1;
		goto done;
		}

		raw_btf = btf_raw_create(&hdr_tmpl, test->expect.raw_types,
		test->expect.str_sec,
		test->expect.str_sec_size,
		&raw_btf_size, &ret_expect_next_str);
		if (!raw_btf)
		return -1;
		expect_btf = btf__new((__u8 *)raw_btf, raw_btf_size);
		free(raw_btf);
		if (CHECK(IS_ERR(expect_btf), "invalid expect_btf errno:%ld",
		PTR_ERR(expect_btf))) {
		err = -1;
		goto done;
		}

		err = btf__dedup(test_btf, NULL, &test->opts);
		if (CHECK(err, "btf_dedup failed errno:%d", err)) {
		err = -1;
		goto done;
		}

		btf__get_strings(test_btf, &test_strs, &test_str_len);
		btf__get_strings(expect_btf, &expect_strs, &expect_str_len);
		if (CHECK(test_str_len != expect_str_len,
		"test_str_len:%u != expect_str_len:%u",
		test_str_len, expect_str_len)) {
		fprintf(stderr, "\ntest strings:\n");
		dump_btf_strings(test_strs, test_str_len);
		fprintf(stderr, "\nexpected strings:\n");
		dump_btf_strings(expect_strs, expect_str_len);
		err = -1;
		goto done;
		}

		test_str_cur = test_strs;
		test_str_end = test_strs + test_str_len;
		expect_str_cur = expect_strs;
		expect_str_end = expect_strs + expect_str_len;
		while (test_str_cur < test_str_end && expect_str_cur < expect_str_end) {
		size_t test_len, expect_len;

		test_len = strlen(test_str_cur);
		expect_len = strlen(expect_str_cur);
		if (CHECK(test_len != expect_len,
		"test_len:%zu != expect_len:%zu "
		"(test_str:%s, expect_str:%s)",
		test_len, expect_len, test_str_cur, expect_str_cur)) {
		err = -1;
		goto done;
		}
		if (CHECK(strcmp(test_str_cur, expect_str_cur),
		"test_str:%s != expect_str:%s",
		test_str_cur, expect_str_cur)) {
		err = -1;
		goto done;
		}
		test_str_cur += test_len + 1;
		expect_str_cur += expect_len + 1;
		}
		if (CHECK(test_str_cur != test_str_end,
		"test_str_cur:%p != test_str_end:%p",
		test_str_cur, test_str_end)) {
		err = -1;
		goto done;
		}

		test_nr_types = btf__get_nr_types(test_btf);
		expect_nr_types = btf__get_nr_types(expect_btf);
		if (CHECK(test_nr_types != expect_nr_types,
		"test_nr_types:%u != expect_nr_types:%u",
		test_nr_types, expect_nr_types)) {
		err = -1;
		goto done;
		}

		for (i = 1; i <= test_nr_types; i++) {
		const struct btf_type test_type, expect_type;
		int test_size, expect_size;

		test_type = btf__type_by_id(test_btf, i);
		expect_type = btf__type_by_id(expect_btf, i);
		test_size = btf_type_size(test_type);
		expect_size = btf_type_size(expect_type);

		if (CHECK(test_size != expect_size,
		"type #%d: test_size:%d != expect_size:%u",
		i, test_size, expect_size)) {
		err = -1;
		goto done;
		}
		if (CHECK(memcmp((void *)test_type,
		(void *)expect_type,
		test_size),
		"type #%d: contents differ", i)) {
		err = -1;
		goto done;
		}
		}

		done:
		if (!err)
		fprintf(stderr, "OK");
		if (!IS_ERR(test_btf))
		btf__free(test_btf);
		if (!IS_ERR(expect_btf))
		btf__free(expect_btf);

		return err;
		}

		static int test_dedup(void)
		{
		unsigned int i;
		int err = 0;

		if (args.dedup_test_num)
		return count_result(do_test_dedup(args.dedup_test_num));

		for (i = 1; i <= ARRAY_SIZE(dedup_tests); i++)
		err \|= count_result(do_test_dedup(i));

		return err;
		}

		static void usage(const char *cmd)
		{
		fprintf(stderr, "Usage: %s [-l] [[-r btf_raw_test_num (1 - %zu)] \|\n"
		"\t[-g btf_get_info_test_num (1 - %zu)] \|\n"
		"\t[-f btf_file_test_num (1 - %zu)] \|\n"
		"\t[-k btf_prog_info_raw_test_num (1 - %zu)] \|\n"
		"\t[-p (pretty print test)]]\n",
		"\t[-p (pretty print test)] \|\n"
		"\t[-d btf_dedup_test_num (1 - %zu)]]\n",
		cmd, ARRAY_SIZE(raw_tests), ARRAY_SIZE(get_info_tests),
		ARRAY_SIZE(file_tests), ARRAY_SIZE(info_raw_tests));
		ARRAY_SIZE(file_tests), ARRAY_SIZE(info_raw_tests),
		ARRAY_SIZE(dedup_tests));
		}

		static int parse_args(int argc, char **argv)
		{
		const char *optstr = "lpk:f:r:g:";
		const char *optstr = "hlpk:f:r:g:d:";
		int opt;

		while ((opt = getopt(argc, argv, optstr)) != -1) {
		@@ -5583,6 +6072,10 @@ static int parse_args(int argc, char **argv)
		args.info_raw_test_num = atoi(optarg);
		args.info_raw_test = true;
		break;
		case 'd':
		args.dedup_test_num = atoi(optarg);
		args.dedup_test = true;
		break;
		case 'h':
		usage(argv[0]);
		exit(0);
		@@ -5624,6 +6117,14 @@ static int parse_args(int argc, char **argv)
		return -1;
		}

		if (args.dedup_test_num &&
		(args.dedup_test_num < 1 \|\|
		args.dedup_test_num > ARRAY_SIZE(dedup_tests))) {
		fprintf(stderr, "BTF dedup test number must be [1 - %zu]\n",
		ARRAY_SIZE(dedup_tests));
		return -1;
		}

		return 0;
		}

		@@ -5659,14 +6160,18 @@ int main(int argc, char **argv)
		if (args.info_raw_test)
		err \|= test_info_raw();

		if (args.dedup_test)
		err \|= test_dedup();

		if (args.raw_test \|\| args.get_info_test \|\| args.file_test \|\|
		args.pprint_test \|\| args.info_raw_test)
		args.pprint_test \|\| args.info_raw_test \|\| args.dedup_test)
		goto done;

		err \|= test_raw();
		err \|= test_get_info();
		err \|= test_file();
		err \|= test_info_raw();
		err \|= test_dedup();

		done:
		print_summary();

Admin message