1// SPDX-License-Identifier: GPL-2.0
  2#include <test_progs.h>
  3#include <bpf/btf.h>
  4
  5static int duration = 0;
  6
  7void btf_dump_printf(void *ctx, const char *fmt, va_list args)
  8{
  9	vfprintf(ctx, fmt, args);
 10}
 11
 12static struct btf_dump_test_case {
 13	const char *name;
 14	const char *file;
 15	bool known_ptr_sz;
 16	struct btf_dump_opts opts;
 17} btf_dump_test_cases[] = {
 18	{"btf_dump: syntax", "btf_dump_test_case_syntax", true, {}},
 19	{"btf_dump: ordering", "btf_dump_test_case_ordering", false, {}},
 20	{"btf_dump: padding", "btf_dump_test_case_padding", true, {}},
 21	{"btf_dump: packing", "btf_dump_test_case_packing", true, {}},
 22	{"btf_dump: bitfields", "btf_dump_test_case_bitfields", true, {}},
 23	{"btf_dump: multidim", "btf_dump_test_case_multidim", false, {}},
 24	{"btf_dump: namespacing", "btf_dump_test_case_namespacing", false, {}},
 25};
 26
 27static int btf_dump_all_types(const struct btf *btf,
 28			      const struct btf_dump_opts *opts)
 29{
 30	size_t type_cnt = btf__get_nr_types(btf);
 31	struct btf_dump *d;
 32	int err = 0, id;
 33
 34	d = btf_dump__new(btf, NULL, opts, btf_dump_printf);
 35	err = libbpf_get_error(d);
 36	if (err)
 37		return err;
 38
 39	for (id = 1; id <= type_cnt; id++) {
 40		err = btf_dump__dump_type(d, id);
 41		if (err)
 42			goto done;
 43	}
 44
 45done:
 46	btf_dump__free(d);
 47	return err;
 48}
 49
 50static int test_btf_dump_case(int n, struct btf_dump_test_case *t)
 51{
 52	char test_file[256], out_file[256], diff_cmd[1024];
 53	struct btf *btf = NULL;
 54	int err = 0, fd = -1;
 55	FILE *f = NULL;
 56
 57	snprintf(test_file, sizeof(test_file), "%s.o", t->file);
 58
 59	btf = btf__parse_elf(test_file, NULL);
 60	if (!ASSERT_OK_PTR(btf, "btf_parse_elf")) {
 61		err = -PTR_ERR(btf);
 62		btf = NULL;
 63		goto done;
 64	}
 65
 66	/* tests with t->known_ptr_sz have no "long" or "unsigned long" type,
 67	 * so it's impossible to determine correct pointer size; but if they
 68	 * do, it should be 8 regardless of host architecture, becaues BPF
 69	 * target is always 64-bit
 70	 */
 71	if (!t->known_ptr_sz) {
 72		btf__set_pointer_size(btf, 8);
 73	} else {
 74		CHECK(btf__pointer_size(btf) != 8, "ptr_sz", "exp %d, got %zu\n",
 75		      8, btf__pointer_size(btf));
 76	}
 77
 78	snprintf(out_file, sizeof(out_file), "/tmp/%s.output.XXXXXX", t->file);
 79	fd = mkstemp(out_file);
 80	if (!ASSERT_GE(fd, 0, "create_tmp")) {
 81		err = fd;
 82		goto done;
 83	}
 84	f = fdopen(fd, "w");
 85	if (CHECK(f == NULL, "open_tmp",  "failed to open file: %s(%d)\n",
 86		  strerror(errno), errno)) {
 87		close(fd);
 88		goto done;
 89	}
 90
 91	t->opts.ctx = f;
 92	err = btf_dump_all_types(btf, &t->opts);
 93	fclose(f);
 94	close(fd);
 95	if (CHECK(err, "btf_dump", "failure during C dumping: %d\n", err)) {
 96		goto done;
 97	}
 98
 99	snprintf(test_file, sizeof(test_file), "progs/%s.c", t->file);
100	if (access(test_file, R_OK) == -1)
101		/*
102		 * When the test is run with O=, kselftest copies TEST_FILES
103		 * without preserving the directory structure.
104		 */
105		snprintf(test_file, sizeof(test_file), "%s.c", t->file);
106	/*
107	 * Diff test output and expected test output, contained between
108	 * START-EXPECTED-OUTPUT and END-EXPECTED-OUTPUT lines in test case.
109	 * For expected output lines, everything before '*' is stripped out.
110	 * Also lines containing comment start and comment end markers are
111	 * ignored. 
112	 */
113	snprintf(diff_cmd, sizeof(diff_cmd),
114		 "awk '/START-EXPECTED-OUTPUT/{out=1;next} "
115		 "/END-EXPECTED-OUTPUT/{out=0} "
116		 "/\\/\\*|\\*\\//{next} " /* ignore comment start/end lines */
117		 "out {sub(/^[ \\t]*\\*/, \"\"); print}' '%s' | diff -u - '%s'",
118		 test_file, out_file);
119	err = system(diff_cmd);
120	if (CHECK(err, "diff",
121		  "differing test output, output=%s, err=%d, diff cmd:\n%s\n",
122		  out_file, err, diff_cmd))
123		goto done;
124
125	remove(out_file);
126
127done:
128	btf__free(btf);
129	return err;
130}
131
132static char *dump_buf;
133static size_t dump_buf_sz;
134static FILE *dump_buf_file;
135
136void test_btf_dump_incremental(void)
137{
138	struct btf *btf = NULL;
139	struct btf_dump *d = NULL;
140	struct btf_dump_opts opts;
141	int id, err, i;
142
143	dump_buf_file = open_memstream(&dump_buf, &dump_buf_sz);
144	if (!ASSERT_OK_PTR(dump_buf_file, "dump_memstream"))
145		return;
146	btf = btf__new_empty();
147	if (!ASSERT_OK_PTR(btf, "new_empty"))
148		goto err_out;
149	opts.ctx = dump_buf_file;
150	d = btf_dump__new(btf, NULL, &opts, btf_dump_printf);
151	if (!ASSERT_OK(libbpf_get_error(d), "btf_dump__new"))
152		goto err_out;
153
154	/* First, generate BTF corresponding to the following C code:
155	 *
156	 * enum { VAL = 1 };
157	 *
158	 * struct s { int x; };
159	 *
160	 */
161	id = btf__add_enum(btf, NULL, 4);
162	ASSERT_EQ(id, 1, "enum_id");
163	err = btf__add_enum_value(btf, "VAL", 1);
164	ASSERT_OK(err, "enum_val_ok");
165
166	id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);
167	ASSERT_EQ(id, 2, "int_id");
168
169	id = btf__add_struct(btf, "s", 4);
170	ASSERT_EQ(id, 3, "struct_id");
171	err = btf__add_field(btf, "x", 2, 0, 0);
172	ASSERT_OK(err, "field_ok");
173
174	for (i = 1; i <= btf__get_nr_types(btf); i++) {
175		err = btf_dump__dump_type(d, i);
176		ASSERT_OK(err, "dump_type_ok");
177	}
178
179	fflush(dump_buf_file);
180	dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */
181	ASSERT_STREQ(dump_buf,
182"enum {\n"
183"	VAL = 1,\n"
184"};\n"
185"\n"
186"struct s {\n"
187"	int x;\n"
188"};\n\n", "c_dump1");
189
190	/* Now, after dumping original BTF, append another struct that embeds
191	 * anonymous enum. It also has a name conflict with the first struct:
192	 *
193	 * struct s___2 {
194	 *     enum { VAL___2 = 1 } x;
195	 *     struct s s;
196	 * };
197	 *
198	 * This will test that btf_dump'er maintains internal state properly.
199	 * Note that VAL___2 enum value. It's because we've already emitted
200	 * that enum as a global anonymous enum, so btf_dump will ensure that
201	 * enum values don't conflict;
202	 *
203	 */
204	fseek(dump_buf_file, 0, SEEK_SET);
205
206	id = btf__add_struct(btf, "s", 4);
207	ASSERT_EQ(id, 4, "struct_id");
208	err = btf__add_field(btf, "x", 1, 0, 0);
209	ASSERT_OK(err, "field_ok");
210	err = btf__add_field(btf, "s", 3, 32, 0);
211	ASSERT_OK(err, "field_ok");
212
213	for (i = 1; i <= btf__get_nr_types(btf); i++) {
214		err = btf_dump__dump_type(d, i);
215		ASSERT_OK(err, "dump_type_ok");
216	}
217
218	fflush(dump_buf_file);
219	dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */
220	ASSERT_STREQ(dump_buf,
221"struct s___2 {\n"
222"	enum {\n"
223"		VAL___2 = 1,\n"
224"	} x;\n"
225"	struct s s;\n"
226"};\n\n" , "c_dump1");
227
228err_out:
229	fclose(dump_buf_file);
230	free(dump_buf);
231	btf_dump__free(d);
232	btf__free(btf);
233}
234
235void test_btf_dump() {
236	int i;
237
238	for (i = 0; i < ARRAY_SIZE(btf_dump_test_cases); i++) {
239		struct btf_dump_test_case *t = &btf_dump_test_cases[i];
240
241		if (!test__start_subtest(t->name))
242			continue;
243
244		test_btf_dump_case(i, &btf_dump_test_cases[i]);
245	}
246	if (test__start_subtest("btf_dump: incremental"))
247		test_btf_dump_incremental();
248}