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

Commit 9c651127 authored by Andrii Nakryiko's avatar Andrii Nakryiko Committed by Daniel Borkmann
Browse files

selftests/btf: add initial BTF dedup tests 



This patch sets up a new kind of tests (BTF dedup tests) and tests few aspects of
BTF dedup algorithm. More complete set of tests will come in follow up patches.

Signed-off-by: default avatarAndrii Nakryiko <andriin@fb.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
parent d5caef5b

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();