1 // SPDX-License-Identifier: GPL-2.0
2 #include <test_progs.h>
3 #include <bpf/btf.h>
4 
5 static int duration = 0;
6 
7 void btf_dump_printf(void *ctx, const char *fmt, va_list args)
8 {
9 	vfprintf(ctx, fmt, args);
10 }
11 
12 static 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 
27 static 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 	if (IS_ERR(d))
36 		return PTR_ERR(d);
37 
38 	for (id = 1; id <= type_cnt; id++) {
39 		err = btf_dump__dump_type(d, id);
40 		if (err)
41 			goto done;
42 	}
43 
44 done:
45 	btf_dump__free(d);
46 	return err;
47 }
48 
49 static int test_btf_dump_case(int n, struct btf_dump_test_case *t)
50 {
51 	char test_file[256], out_file[256], diff_cmd[1024];
52 	struct btf *btf = NULL;
53 	int err = 0, fd = -1;
54 	FILE *f = NULL;
55 
56 	snprintf(test_file, sizeof(test_file), "%s.o", t->file);
57 
58 	btf = btf__parse_elf(test_file, NULL);
59 	if (CHECK(IS_ERR(btf), "btf_parse_elf",
60 	    "failed to load test BTF: %ld\n", PTR_ERR(btf))) {
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 (CHECK(fd < 0, "create_tmp", "failed to create file: %d\n", fd)) {
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 
127 done:
128 	btf__free(btf);
129 	return err;
130 }
131 
132 static char *dump_buf;
133 static size_t dump_buf_sz;
134 static FILE *dump_buf_file;
135 
136 void 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 
228 err_out:
229 	fclose(dump_buf_file);
230 	free(dump_buf);
231 	btf_dump__free(d);
232 	btf__free(btf);
233 }
234 
235 void 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 }
249