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 } btf_dump_test_cases[] = {
17 	{"btf_dump: syntax", "btf_dump_test_case_syntax", true},
18 	{"btf_dump: ordering", "btf_dump_test_case_ordering", false},
19 	{"btf_dump: padding", "btf_dump_test_case_padding", true},
20 	{"btf_dump: packing", "btf_dump_test_case_packing", true},
21 	{"btf_dump: bitfields", "btf_dump_test_case_bitfields", true},
22 	{"btf_dump: multidim", "btf_dump_test_case_multidim", false},
23 	{"btf_dump: namespacing", "btf_dump_test_case_namespacing", false},
24 };
25 
26 static int btf_dump_all_types(const struct btf *btf, void *ctx)
27 {
28 	size_t type_cnt = btf__type_cnt(btf);
29 	struct btf_dump *d;
30 	int err = 0, id;
31 
32 	d = btf_dump__new(btf, btf_dump_printf, ctx, NULL);
33 	err = libbpf_get_error(d);
34 	if (err)
35 		return err;
36 
37 	for (id = 1; id < type_cnt; id++) {
38 		err = btf_dump__dump_type(d, id);
39 		if (err)
40 			goto done;
41 	}
42 
43 done:
44 	btf_dump__free(d);
45 	return err;
46 }
47 
48 static int test_btf_dump_case(int n, struct btf_dump_test_case *t)
49 {
50 	char test_file[256], out_file[256], diff_cmd[1024];
51 	struct btf *btf = NULL;
52 	int err = 0, fd = -1;
53 	FILE *f = NULL;
54 
55 	snprintf(test_file, sizeof(test_file), "%s.bpf.o", t->file);
56 
57 	btf = btf__parse_elf(test_file, NULL);
58 	if (!ASSERT_OK_PTR(btf, "btf_parse_elf")) {
59 		err = -PTR_ERR(btf);
60 		btf = NULL;
61 		goto done;
62 	}
63 
64 	/* tests with t->known_ptr_sz have no "long" or "unsigned long" type,
65 	 * so it's impossible to determine correct pointer size; but if they
66 	 * do, it should be 8 regardless of host architecture, becaues BPF
67 	 * target is always 64-bit
68 	 */
69 	if (!t->known_ptr_sz) {
70 		btf__set_pointer_size(btf, 8);
71 	} else {
72 		CHECK(btf__pointer_size(btf) != 8, "ptr_sz", "exp %d, got %zu\n",
73 		      8, btf__pointer_size(btf));
74 	}
75 
76 	snprintf(out_file, sizeof(out_file), "/tmp/%s.output.XXXXXX", t->file);
77 	fd = mkstemp(out_file);
78 	if (!ASSERT_GE(fd, 0, "create_tmp")) {
79 		err = fd;
80 		goto done;
81 	}
82 	f = fdopen(fd, "w");
83 	if (CHECK(f == NULL, "open_tmp",  "failed to open file: %s(%d)\n",
84 		  strerror(errno), errno)) {
85 		close(fd);
86 		goto done;
87 	}
88 
89 	err = btf_dump_all_types(btf, f);
90 	fclose(f);
91 	close(fd);
92 	if (CHECK(err, "btf_dump", "failure during C dumping: %d\n", err)) {
93 		goto done;
94 	}
95 
96 	snprintf(test_file, sizeof(test_file), "progs/%s.c", t->file);
97 	if (access(test_file, R_OK) == -1)
98 		/*
99 		 * When the test is run with O=, kselftest copies TEST_FILES
100 		 * without preserving the directory structure.
101 		 */
102 		snprintf(test_file, sizeof(test_file), "%s.c", t->file);
103 	/*
104 	 * Diff test output and expected test output, contained between
105 	 * START-EXPECTED-OUTPUT and END-EXPECTED-OUTPUT lines in test case.
106 	 * For expected output lines, everything before '*' is stripped out.
107 	 * Also lines containing comment start and comment end markers are
108 	 * ignored.
109 	 */
110 	snprintf(diff_cmd, sizeof(diff_cmd),
111 		 "awk '/START-EXPECTED-OUTPUT/{out=1;next} "
112 		 "/END-EXPECTED-OUTPUT/{out=0} "
113 		 "/\\/\\*|\\*\\//{next} " /* ignore comment start/end lines */
114 		 "out {sub(/^[ \\t]*\\*/, \"\"); print}' '%s' | diff -u - '%s'",
115 		 test_file, out_file);
116 	err = system(diff_cmd);
117 	if (CHECK(err, "diff",
118 		  "differing test output, output=%s, err=%d, diff cmd:\n%s\n",
119 		  out_file, err, diff_cmd))
120 		goto done;
121 
122 	remove(out_file);
123 
124 done:
125 	btf__free(btf);
126 	return err;
127 }
128 
129 static char *dump_buf;
130 static size_t dump_buf_sz;
131 static FILE *dump_buf_file;
132 
133 static void test_btf_dump_incremental(void)
134 {
135 	struct btf *btf = NULL;
136 	struct btf_dump *d = NULL;
137 	int id, err, i;
138 
139 	dump_buf_file = open_memstream(&dump_buf, &dump_buf_sz);
140 	if (!ASSERT_OK_PTR(dump_buf_file, "dump_memstream"))
141 		return;
142 	btf = btf__new_empty();
143 	if (!ASSERT_OK_PTR(btf, "new_empty"))
144 		goto err_out;
145 	d = btf_dump__new(btf, btf_dump_printf, dump_buf_file, NULL);
146 	if (!ASSERT_OK(libbpf_get_error(d), "btf_dump__new"))
147 		goto err_out;
148 
149 	/* First, generate BTF corresponding to the following C code:
150 	 *
151 	 * enum x;
152 	 *
153 	 * enum x { X = 1 };
154 	 *
155 	 * enum { Y = 1 };
156 	 *
157 	 * struct s;
158 	 *
159 	 * struct s { int x; };
160 	 *
161 	 */
162 	id = btf__add_enum(btf, "x", 4);
163 	ASSERT_EQ(id, 1, "enum_declaration_id");
164 	id = btf__add_enum(btf, "x", 4);
165 	ASSERT_EQ(id, 2, "named_enum_id");
166 	err = btf__add_enum_value(btf, "X", 1);
167 	ASSERT_OK(err, "named_enum_val_ok");
168 
169 	id = btf__add_enum(btf, NULL, 4);
170 	ASSERT_EQ(id, 3, "anon_enum_id");
171 	err = btf__add_enum_value(btf, "Y", 1);
172 	ASSERT_OK(err, "anon_enum_val_ok");
173 
174 	id = btf__add_int(btf, "int", 4, BTF_INT_SIGNED);
175 	ASSERT_EQ(id, 4, "int_id");
176 
177 	id = btf__add_fwd(btf, "s", BTF_FWD_STRUCT);
178 	ASSERT_EQ(id, 5, "fwd_id");
179 
180 	id = btf__add_struct(btf, "s", 4);
181 	ASSERT_EQ(id, 6, "struct_id");
182 	err = btf__add_field(btf, "x", 4, 0, 0);
183 	ASSERT_OK(err, "field_ok");
184 
185 	for (i = 1; i < btf__type_cnt(btf); i++) {
186 		err = btf_dump__dump_type(d, i);
187 		ASSERT_OK(err, "dump_type_ok");
188 	}
189 
190 	fflush(dump_buf_file);
191 	dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */
192 
193 	ASSERT_STREQ(dump_buf,
194 "enum x;\n"
195 "\n"
196 "enum x {\n"
197 "	X = 1,\n"
198 "};\n"
199 "\n"
200 "enum {\n"
201 "	Y = 1,\n"
202 "};\n"
203 "\n"
204 "struct s;\n"
205 "\n"
206 "struct s {\n"
207 "	int x;\n"
208 "};\n\n", "c_dump1");
209 
210 	/* Now, after dumping original BTF, append another struct that embeds
211 	 * anonymous enum. It also has a name conflict with the first struct:
212 	 *
213 	 * struct s___2 {
214 	 *     enum { VAL___2 = 1 } x;
215 	 *     struct s s;
216 	 * };
217 	 *
218 	 * This will test that btf_dump'er maintains internal state properly.
219 	 * Note that VAL___2 enum value. It's because we've already emitted
220 	 * that enum as a global anonymous enum, so btf_dump will ensure that
221 	 * enum values don't conflict;
222 	 *
223 	 */
224 	fseek(dump_buf_file, 0, SEEK_SET);
225 
226 	id = btf__add_struct(btf, "s", 4);
227 	ASSERT_EQ(id, 7, "struct_id");
228 	err = btf__add_field(btf, "x", 2, 0, 0);
229 	ASSERT_OK(err, "field_ok");
230 	err = btf__add_field(btf, "y", 3, 32, 0);
231 	ASSERT_OK(err, "field_ok");
232 	err = btf__add_field(btf, "s", 6, 64, 0);
233 	ASSERT_OK(err, "field_ok");
234 
235 	for (i = 1; i < btf__type_cnt(btf); i++) {
236 		err = btf_dump__dump_type(d, i);
237 		ASSERT_OK(err, "dump_type_ok");
238 	}
239 
240 	fflush(dump_buf_file);
241 	dump_buf[dump_buf_sz] = 0; /* some libc implementations don't do this */
242 	ASSERT_STREQ(dump_buf,
243 "struct s___2 {\n"
244 "	enum x x;\n"
245 "	enum {\n"
246 "		Y___2 = 1,\n"
247 "	} y;\n"
248 "	struct s s;\n"
249 "};\n\n" , "c_dump1");
250 
251 err_out:
252 	fclose(dump_buf_file);
253 	free(dump_buf);
254 	btf_dump__free(d);
255 	btf__free(btf);
256 }
257 
258 #define STRSIZE				4096
259 
260 static void btf_dump_snprintf(void *ctx, const char *fmt, va_list args)
261 {
262 	char *s = ctx, new[STRSIZE];
263 
264 	vsnprintf(new, STRSIZE, fmt, args);
265 	if (strlen(s) < STRSIZE)
266 		strncat(s, new, STRSIZE - strlen(s) - 1);
267 }
268 
269 static int btf_dump_data(struct btf *btf, struct btf_dump *d,
270 			 char *name, char *prefix, __u64 flags, void *ptr,
271 			 size_t ptr_sz, char *str, const char *expected_val)
272 {
273 	DECLARE_LIBBPF_OPTS(btf_dump_type_data_opts, opts);
274 	size_t type_sz;
275 	__s32 type_id;
276 	int ret = 0;
277 
278 	if (flags & BTF_F_COMPACT)
279 		opts.compact = true;
280 	if (flags & BTF_F_NONAME)
281 		opts.skip_names = true;
282 	if (flags & BTF_F_ZERO)
283 		opts.emit_zeroes = true;
284 	if (prefix) {
285 		ASSERT_STRNEQ(name, prefix, strlen(prefix),
286 			      "verify prefix match");
287 		name += strlen(prefix) + 1;
288 	}
289 	type_id = btf__find_by_name(btf, name);
290 	if (!ASSERT_GE(type_id, 0, "find type id"))
291 		return -ENOENT;
292 	type_sz = btf__resolve_size(btf, type_id);
293 	str[0] = '\0';
294 	ret = btf_dump__dump_type_data(d, type_id, ptr, ptr_sz, &opts);
295 	if (type_sz <= ptr_sz) {
296 		if (!ASSERT_EQ(ret, type_sz, "failed/unexpected type_sz"))
297 			return -EINVAL;
298 	} else {
299 		if (!ASSERT_EQ(ret, -E2BIG, "failed to return -E2BIG"))
300 			return -EINVAL;
301 	}
302 	if (!ASSERT_STREQ(str, expected_val, "ensure expected/actual match"))
303 		return -EFAULT;
304 	return 0;
305 }
306 
307 #define TEST_BTF_DUMP_DATA(_b, _d, _prefix, _str, _type, _flags,	\
308 			   _expected, ...)				\
309 	do {								\
310 		char __ptrtype[64] = #_type;				\
311 		char *_ptrtype = (char *)__ptrtype;			\
312 		_type _ptrdata = __VA_ARGS__;				\
313 		void *_ptr = &_ptrdata;					\
314 									\
315 		(void) btf_dump_data(_b, _d, _ptrtype, _prefix, _flags,	\
316 				     _ptr, sizeof(_type), _str,		\
317 				     _expected);			\
318 	} while (0)
319 
320 /* Use where expected data string matches its stringified declaration */
321 #define TEST_BTF_DUMP_DATA_C(_b, _d, _prefix,  _str, _type, _flags,	\
322 			     ...)					\
323 	TEST_BTF_DUMP_DATA(_b, _d, _prefix, _str, _type, _flags,	\
324 			   "(" #_type ")" #__VA_ARGS__,	__VA_ARGS__)
325 
326 /* overflow test; pass typesize < expected type size, ensure E2BIG returned */
327 #define TEST_BTF_DUMP_DATA_OVER(_b, _d, _prefix, _str, _type, _type_sz,	\
328 				_expected, ...)				\
329 	do {								\
330 		char __ptrtype[64] = #_type;				\
331 		char *_ptrtype = (char *)__ptrtype;			\
332 		_type _ptrdata = __VA_ARGS__;				\
333 		void *_ptr = &_ptrdata;					\
334 									\
335 		(void) btf_dump_data(_b, _d, _ptrtype, _prefix, 0,	\
336 				     _ptr, _type_sz, _str, _expected);	\
337 	} while (0)
338 
339 #define TEST_BTF_DUMP_VAR(_b, _d, _prefix, _str, _var, _type, _flags,	\
340 			  _expected, ...)				\
341 	do {								\
342 		_type _ptrdata = __VA_ARGS__;				\
343 		void *_ptr = &_ptrdata;					\
344 									\
345 		(void) btf_dump_data(_b, _d, _var, _prefix, _flags,	\
346 				     _ptr, sizeof(_type), _str,		\
347 				     _expected);			\
348 	} while (0)
349 
350 static void test_btf_dump_int_data(struct btf *btf, struct btf_dump *d,
351 				   char *str)
352 {
353 #ifdef __SIZEOF_INT128__
354 	unsigned __int128 i = 0xffffffffffffffff;
355 
356 	/* this dance is required because we cannot directly initialize
357 	 * a 128-bit value to anything larger than a 64-bit value.
358 	 */
359 	i = (i << 64) | (i - 1);
360 #endif
361 	/* simple int */
362 	TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, int, BTF_F_COMPACT, 1234);
363 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,
364 			   "1234", 1234);
365 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, 0, "(int)1234", 1234);
366 
367 	/* zero value should be printed at toplevel */
368 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT, "(int)0", 0);
369 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,
370 			   "0", 0);
371 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_ZERO,
372 			   "(int)0", 0);
373 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int,
374 			   BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
375 			   "0", 0);
376 	TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, int, BTF_F_COMPACT, -4567);
377 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, BTF_F_COMPACT | BTF_F_NONAME,
378 			   "-4567", -4567);
379 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, int, 0, "(int)-4567", -4567);
380 
381 	TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, int, sizeof(int)-1, "", 1);
382 
383 #ifdef __SIZEOF_INT128__
384 	/* gcc encode unsigned __int128 type with name "__int128 unsigned" in dwarf,
385 	 * and clang encode it with name "unsigned __int128" in dwarf.
386 	 * Do an availability test for either variant before doing actual test.
387 	 */
388 	if (btf__find_by_name(btf, "unsigned __int128") > 0) {
389 		TEST_BTF_DUMP_DATA(btf, d, NULL, str, unsigned __int128, BTF_F_COMPACT,
390 				   "(unsigned __int128)0xffffffffffffffff",
391 				   0xffffffffffffffff);
392 		ASSERT_OK(btf_dump_data(btf, d, "unsigned __int128", NULL, 0, &i, 16, str,
393 					"(unsigned __int128)0xfffffffffffffffffffffffffffffffe"),
394 			  "dump unsigned __int128");
395 	} else if (btf__find_by_name(btf, "__int128 unsigned") > 0) {
396 		TEST_BTF_DUMP_DATA(btf, d, NULL, str, __int128 unsigned, BTF_F_COMPACT,
397 				   "(__int128 unsigned)0xffffffffffffffff",
398 				   0xffffffffffffffff);
399 		ASSERT_OK(btf_dump_data(btf, d, "__int128 unsigned", NULL, 0, &i, 16, str,
400 					"(__int128 unsigned)0xfffffffffffffffffffffffffffffffe"),
401 			  "dump unsigned __int128");
402 	} else {
403 		ASSERT_TRUE(false, "unsigned_int128_not_found");
404 	}
405 #endif
406 }
407 
408 static void test_btf_dump_float_data(struct btf *btf, struct btf_dump *d,
409 				     char *str)
410 {
411 	float t1 = 1.234567;
412 	float t2 = -1.234567;
413 	float t3 = 0.0;
414 	double t4 = 5.678912;
415 	double t5 = -5.678912;
416 	double t6 = 0.0;
417 	long double t7 = 9.876543;
418 	long double t8 = -9.876543;
419 	long double t9 = 0.0;
420 
421 	/* since the kernel does not likely have any float types in its BTF, we
422 	 * will need to add some of various sizes.
423 	 */
424 
425 	ASSERT_GT(btf__add_float(btf, "test_float", 4), 0, "add float");
426 	ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t1, 4, str,
427 				"(test_float)1.234567"), "dump float");
428 	ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t2, 4, str,
429 				"(test_float)-1.234567"), "dump float");
430 	ASSERT_OK(btf_dump_data(btf, d, "test_float", NULL, 0, &t3, 4, str,
431 				"(test_float)0.000000"), "dump float");
432 
433 	ASSERT_GT(btf__add_float(btf, "test_double", 8), 0, "add_double");
434 	ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t4, 8, str,
435 		  "(test_double)5.678912"), "dump double");
436 	ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t5, 8, str,
437 		  "(test_double)-5.678912"), "dump double");
438 	ASSERT_OK(btf_dump_data(btf, d, "test_double", NULL, 0, &t6, 8, str,
439 				"(test_double)0.000000"), "dump double");
440 
441 	ASSERT_GT(btf__add_float(btf, "test_long_double", 16), 0, "add long double");
442 	ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t7, 16,
443 				str, "(test_long_double)9.876543"),
444 				"dump long_double");
445 	ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t8, 16,
446 				str, "(test_long_double)-9.876543"),
447 				"dump long_double");
448 	ASSERT_OK(btf_dump_data(btf, d, "test_long_double", NULL, 0, &t9, 16,
449 				str, "(test_long_double)0.000000"),
450 				"dump long_double");
451 }
452 
453 static void test_btf_dump_char_data(struct btf *btf, struct btf_dump *d,
454 				    char *str)
455 {
456 	/* simple char */
457 	TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, char, BTF_F_COMPACT, 100);
458 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME,
459 			   "100", 100);
460 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, 0, "(char)100", 100);
461 	/* zero value should be printed at toplevel */
462 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT,
463 			   "(char)0", 0);
464 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME,
465 			   "0", 0);
466 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_ZERO,
467 			   "(char)0", 0);
468 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
469 			   "0", 0);
470 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, char, 0, "(char)0", 0);
471 
472 	TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, char, sizeof(char)-1, "", 100);
473 }
474 
475 static void test_btf_dump_typedef_data(struct btf *btf, struct btf_dump *d,
476 				       char *str)
477 {
478 	/* simple typedef */
479 	TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, uint64_t, BTF_F_COMPACT, 100);
480 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_NONAME,
481 			   "1", 1);
482 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, 0, "(u64)1", 1);
483 	/* zero value should be printed at toplevel */
484 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT, "(u64)0", 0);
485 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_NONAME,
486 			   "0", 0);
487 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, BTF_F_COMPACT | BTF_F_ZERO,
488 			   "(u64)0", 0);
489 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64,
490 			   BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
491 			   "0", 0);
492 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, u64, 0, "(u64)0", 0);
493 
494 	/* typedef struct */
495 	TEST_BTF_DUMP_DATA_C(btf, d, NULL, str, atomic_t, BTF_F_COMPACT,
496 			     {.counter = (int)1,});
497 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_NONAME,
498 			   "{1,}", { .counter = 1 });
499 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, 0,
500 "(atomic_t){\n"
501 "	.counter = (int)1,\n"
502 "}",
503 			   {.counter = 1,});
504 	/* typedef with 0 value should be printed at toplevel */
505 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT, "(atomic_t){}",
506 			   {.counter = 0,});
507 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_NONAME,
508 			   "{}", {.counter = 0,});
509 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, 0,
510 "(atomic_t){\n"
511 "}",
512 			   {.counter = 0,});
513 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_COMPACT | BTF_F_ZERO,
514 			   "(atomic_t){.counter = (int)0,}",
515 			   {.counter = 0,});
516 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t,
517 			   BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
518 			   "{0,}", {.counter = 0,});
519 	TEST_BTF_DUMP_DATA(btf, d, NULL, str, atomic_t, BTF_F_ZERO,
520 "(atomic_t){\n"
521 "	.counter = (int)0,\n"
522 "}",
523 			   { .counter = 0,});
524 
525 	/* overflow should show type but not value since it overflows */
526 	TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, atomic_t, sizeof(atomic_t)-1,
527 				"(atomic_t){\n", { .counter = 1});
528 }
529 
530 static void test_btf_dump_enum_data(struct btf *btf, struct btf_dump *d,
531 				    char *str)
532 {
533 	/* enum where enum value does (and does not) exist */
534 	TEST_BTF_DUMP_DATA_C(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT,
535 			     BPF_MAP_CREATE);
536 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT,
537 			   "(enum bpf_cmd)BPF_MAP_CREATE", 0);
538 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,
539 			   BTF_F_COMPACT | BTF_F_NONAME,
540 			   "BPF_MAP_CREATE",
541 			   BPF_MAP_CREATE);
542 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, 0,
543 			   "(enum bpf_cmd)BPF_MAP_CREATE",
544 			   BPF_MAP_CREATE);
545 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,
546 			   BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
547 			   "BPF_MAP_CREATE", 0);
548 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,
549 			   BTF_F_COMPACT | BTF_F_ZERO,
550 			   "(enum bpf_cmd)BPF_MAP_CREATE",
551 			   BPF_MAP_CREATE);
552 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,
553 			   BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
554 			   "BPF_MAP_CREATE", BPF_MAP_CREATE);
555 	TEST_BTF_DUMP_DATA_C(btf, d, "enum", str, enum bpf_cmd, BTF_F_COMPACT, 2000);
556 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd,
557 			   BTF_F_COMPACT | BTF_F_NONAME,
558 			   "2000", 2000);
559 	TEST_BTF_DUMP_DATA(btf, d, "enum", str, enum bpf_cmd, 0,
560 			   "(enum bpf_cmd)2000", 2000);
561 
562 	TEST_BTF_DUMP_DATA_OVER(btf, d, "enum", str, enum bpf_cmd,
563 				sizeof(enum bpf_cmd) - 1, "", BPF_MAP_CREATE);
564 }
565 
566 static void test_btf_dump_struct_data(struct btf *btf, struct btf_dump *d,
567 				      char *str)
568 {
569 	DECLARE_LIBBPF_OPTS(btf_dump_type_data_opts, opts);
570 	char zero_data[512] = { };
571 	char type_data[512];
572 	void *fops = type_data;
573 	void *skb = type_data;
574 	size_t type_sz;
575 	__s32 type_id;
576 	char *cmpstr;
577 	int ret;
578 
579 	memset(type_data, 255, sizeof(type_data));
580 
581 	/* simple struct */
582 	TEST_BTF_DUMP_DATA_C(btf, d, "struct", str, struct btf_enum, BTF_F_COMPACT,
583 			     {.name_off = (__u32)3,.val = (__s32)-1,});
584 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,
585 			   BTF_F_COMPACT | BTF_F_NONAME,
586 			   "{3,-1,}",
587 			   { .name_off = 3, .val = -1,});
588 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, 0,
589 "(struct btf_enum){\n"
590 "	.name_off = (__u32)3,\n"
591 "	.val = (__s32)-1,\n"
592 "}",
593 			   { .name_off = 3, .val = -1,});
594 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,
595 			   BTF_F_COMPACT | BTF_F_NONAME,
596 			   "{-1,}",
597 			   { .name_off = 0, .val = -1,});
598 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,
599 			   BTF_F_COMPACT | BTF_F_NONAME | BTF_F_ZERO,
600 			   "{0,-1,}",
601 			   { .name_off = 0, .val = -1,});
602 	/* empty struct should be printed */
603 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, BTF_F_COMPACT,
604 			   "(struct btf_enum){}",
605 			   { .name_off = 0, .val = 0,});
606 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,
607 			   BTF_F_COMPACT | BTF_F_NONAME,
608 			   "{}",
609 			   { .name_off = 0, .val = 0,});
610 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum, 0,
611 "(struct btf_enum){\n"
612 "}",
613 			   { .name_off = 0, .val = 0,});
614 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,
615 			   BTF_F_COMPACT | BTF_F_ZERO,
616 			   "(struct btf_enum){.name_off = (__u32)0,.val = (__s32)0,}",
617 			   { .name_off = 0, .val = 0,});
618 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct btf_enum,
619 			   BTF_F_ZERO,
620 "(struct btf_enum){\n"
621 "	.name_off = (__u32)0,\n"
622 "	.val = (__s32)0,\n"
623 "}",
624 			   { .name_off = 0, .val = 0,});
625 
626 	/* struct with pointers */
627 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, BTF_F_COMPACT,
628 			   "(struct list_head){.next = (struct list_head *)0x1,}",
629 			   { .next = (struct list_head *)1 });
630 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, 0,
631 "(struct list_head){\n"
632 "	.next = (struct list_head *)0x1,\n"
633 "}",
634 			   { .next = (struct list_head *)1 });
635 	/* NULL pointer should not be displayed */
636 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, BTF_F_COMPACT,
637 			   "(struct list_head){}",
638 			   { .next = (struct list_head *)0 });
639 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct list_head, 0,
640 "(struct list_head){\n"
641 "}",
642 			   { .next = (struct list_head *)0 });
643 
644 	/* struct with function pointers */
645 	type_id = btf__find_by_name(btf, "file_operations");
646 	if (ASSERT_GT(type_id, 0, "find type id")) {
647 		type_sz = btf__resolve_size(btf, type_id);
648 		str[0] = '\0';
649 
650 		ret = btf_dump__dump_type_data(d, type_id, fops, type_sz, &opts);
651 		ASSERT_EQ(ret, type_sz,
652 			  "unexpected return value dumping file_operations");
653 		cmpstr =
654 "(struct file_operations){\n"
655 "	.owner = (struct module *)0xffffffffffffffff,\n"
656 "	.llseek = (loff_t (*)(struct file *, loff_t, int))0xffffffffffffffff,";
657 
658 		ASSERT_STRNEQ(str, cmpstr, strlen(cmpstr), "file_operations");
659 	}
660 
661 	/* struct with char array */
662 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,
663 			   "(struct bpf_prog_info){.name = (char[16])['f','o','o',],}",
664 			   { .name = "foo",});
665 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info,
666 			   BTF_F_COMPACT | BTF_F_NONAME,
667 			   "{['f','o','o',],}",
668 			   {.name = "foo",});
669 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, 0,
670 "(struct bpf_prog_info){\n"
671 "	.name = (char[16])[\n"
672 "		'f',\n"
673 "		'o',\n"
674 "		'o',\n"
675 "	],\n"
676 "}",
677 			   {.name = "foo",});
678 	/* leading null char means do not display string */
679 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,
680 			   "(struct bpf_prog_info){}",
681 			   {.name = {'\0', 'f', 'o', 'o'}});
682 	/* handle non-printable characters */
683 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_prog_info, BTF_F_COMPACT,
684 			   "(struct bpf_prog_info){.name = (char[16])[1,2,3,],}",
685 			   { .name = {1, 2, 3, 0}});
686 
687 	/* struct with non-char array */
688 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, BTF_F_COMPACT,
689 			   "(struct __sk_buff){.cb = (__u32[5])[1,2,3,4,5,],}",
690 			   { .cb = {1, 2, 3, 4, 5,},});
691 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff,
692 			   BTF_F_COMPACT | BTF_F_NONAME,
693 			   "{[1,2,3,4,5,],}",
694 			   { .cb = { 1, 2, 3, 4, 5},});
695 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, 0,
696 "(struct __sk_buff){\n"
697 "	.cb = (__u32[5])[\n"
698 "		1,\n"
699 "		2,\n"
700 "		3,\n"
701 "		4,\n"
702 "		5,\n"
703 "	],\n"
704 "}",
705 			   { .cb = { 1, 2, 3, 4, 5},});
706 	/* For non-char, arrays, show non-zero values only */
707 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, BTF_F_COMPACT,
708 			   "(struct __sk_buff){.cb = (__u32[5])[0,0,1,0,0,],}",
709 			   { .cb = { 0, 0, 1, 0, 0},});
710 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct __sk_buff, 0,
711 "(struct __sk_buff){\n"
712 "	.cb = (__u32[5])[\n"
713 "		0,\n"
714 "		0,\n"
715 "		1,\n"
716 "		0,\n"
717 "		0,\n"
718 "	],\n"
719 "}",
720 			   { .cb = { 0, 0, 1, 0, 0},});
721 
722 	/* struct with bitfields */
723 	TEST_BTF_DUMP_DATA_C(btf, d, "struct", str, struct bpf_insn, BTF_F_COMPACT,
724 		{.code = (__u8)1,.dst_reg = (__u8)0x2,.src_reg = (__u8)0x3,.off = (__s16)4,.imm = (__s32)5,});
725 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn,
726 			   BTF_F_COMPACT | BTF_F_NONAME,
727 			   "{1,0x2,0x3,4,5,}",
728 			   { .code = 1, .dst_reg = 0x2, .src_reg = 0x3, .off = 4,
729 			     .imm = 5,});
730 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn, 0,
731 "(struct bpf_insn){\n"
732 "	.code = (__u8)1,\n"
733 "	.dst_reg = (__u8)0x2,\n"
734 "	.src_reg = (__u8)0x3,\n"
735 "	.off = (__s16)4,\n"
736 "	.imm = (__s32)5,\n"
737 "}",
738 			   {.code = 1, .dst_reg = 2, .src_reg = 3, .off = 4, .imm = 5});
739 
740 	/* zeroed bitfields should not be displayed */
741 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_insn, BTF_F_COMPACT,
742 			   "(struct bpf_insn){.dst_reg = (__u8)0x1,}",
743 			   { .code = 0, .dst_reg = 1});
744 
745 	/* struct with enum bitfield */
746 	type_id = btf__find_by_name(btf, "fs_context");
747 	if (ASSERT_GT(type_id,  0, "find fs_context")) {
748 		type_sz = btf__resolve_size(btf, type_id);
749 		str[0] = '\0';
750 
751 		opts.emit_zeroes = true;
752 		ret = btf_dump__dump_type_data(d, type_id, zero_data, type_sz, &opts);
753 		ASSERT_EQ(ret, type_sz,
754 			  "unexpected return value dumping fs_context");
755 
756 		ASSERT_NEQ(strstr(str, "FS_CONTEXT_FOR_MOUNT"), NULL,
757 				  "bitfield value not present");
758 	}
759 
760 	/* struct with nested anon union */
761 	TEST_BTF_DUMP_DATA(btf, d, "struct", str, struct bpf_sock_ops, BTF_F_COMPACT,
762 			   "(struct bpf_sock_ops){.op = (__u32)1,(union){.args = (__u32[4])[1,2,3,4,],.reply = (__u32)1,.replylong = (__u32[4])[1,2,3,4,],},}",
763 			   { .op = 1, .args = { 1, 2, 3, 4}});
764 
765 	/* union with nested struct */
766 	TEST_BTF_DUMP_DATA(btf, d, "union", str, union bpf_iter_link_info, BTF_F_COMPACT,
767 			   "(union bpf_iter_link_info){.map = (struct){.map_fd = (__u32)1,},.cgroup = (struct){.order = (enum bpf_cgroup_iter_order)BPF_CGROUP_ITER_SELF_ONLY,.cgroup_fd = (__u32)1,},.task = (struct){.tid = (__u32)1,.pid = (__u32)1,},}",
768 			   { .cgroup = { .order = 1, .cgroup_fd = 1, }});
769 
770 	/* struct skb with nested structs/unions; because type output is so
771 	 * complex, we don't do a string comparison, just verify we return
772 	 * the type size as the amount of data displayed.
773 	 */
774 	type_id = btf__find_by_name(btf, "sk_buff");
775 	if (ASSERT_GT(type_id, 0, "find struct sk_buff")) {
776 		type_sz = btf__resolve_size(btf, type_id);
777 		str[0] = '\0';
778 
779 		ret = btf_dump__dump_type_data(d, type_id, skb, type_sz, &opts);
780 		ASSERT_EQ(ret, type_sz,
781 			  "unexpected return value dumping sk_buff");
782 	}
783 
784 	/* overflow bpf_sock_ops struct with final element nonzero/zero.
785 	 * Regardless of the value of the final field, we don't have all the
786 	 * data we need to display it, so we should trigger an overflow.
787 	 * In other words overflow checking should trump "is field zero?"
788 	 * checks because if we've overflowed, it shouldn't matter what the
789 	 * field is - we can't trust its value so shouldn't display it.
790 	 */
791 	TEST_BTF_DUMP_DATA_OVER(btf, d, "struct", str, struct bpf_sock_ops,
792 				sizeof(struct bpf_sock_ops) - 1,
793 				"(struct bpf_sock_ops){\n\t.op = (__u32)1,\n",
794 				{ .op = 1, .skb_hwtstamp = 2});
795 	TEST_BTF_DUMP_DATA_OVER(btf, d, "struct", str, struct bpf_sock_ops,
796 				sizeof(struct bpf_sock_ops) - 1,
797 				"(struct bpf_sock_ops){\n\t.op = (__u32)1,\n",
798 				{ .op = 1, .skb_hwtstamp = 0});
799 }
800 
801 static void test_btf_dump_var_data(struct btf *btf, struct btf_dump *d,
802 				   char *str)
803 {
804 #if 0
805 	TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_number", int, BTF_F_COMPACT,
806 			  "int cpu_number = (int)100", 100);
807 #endif
808 	TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_profile_flip", int, BTF_F_COMPACT,
809 			  "static int cpu_profile_flip = (int)2", 2);
810 }
811 
812 static void test_btf_datasec(struct btf *btf, struct btf_dump *d, char *str,
813 			     const char *name, const char *expected_val,
814 			     void *data, size_t data_sz)
815 {
816 	DECLARE_LIBBPF_OPTS(btf_dump_type_data_opts, opts);
817 	int ret = 0, cmp;
818 	size_t secsize;
819 	__s32 type_id;
820 
821 	opts.compact = true;
822 
823 	type_id = btf__find_by_name(btf, name);
824 	if (!ASSERT_GT(type_id, 0, "find type id"))
825 		return;
826 
827 	secsize = btf__resolve_size(btf, type_id);
828 	ASSERT_EQ(secsize,  0, "verify section size");
829 
830 	str[0] = '\0';
831 	ret = btf_dump__dump_type_data(d, type_id, data, data_sz, &opts);
832 	ASSERT_EQ(ret, 0, "unexpected return value");
833 
834 	cmp = strcmp(str, expected_val);
835 	ASSERT_EQ(cmp, 0, "ensure expected/actual match");
836 }
837 
838 static void test_btf_dump_datasec_data(char *str)
839 {
840 	struct btf *btf;
841 	char license[4] = "GPL";
842 	struct btf_dump *d;
843 
844 	btf = btf__parse("xdping_kern.bpf.o", NULL);
845 	if (!ASSERT_OK_PTR(btf, "xdping_kern.bpf.o BTF not found"))
846 		return;
847 
848 	d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);
849 	if (!ASSERT_OK_PTR(d, "could not create BTF dump"))
850 		goto out;
851 
852 	test_btf_datasec(btf, d, str, "license",
853 			 "SEC(\"license\") char[4] _license = (char[4])['G','P','L',];",
854 			 license, sizeof(license));
855 out:
856 	btf_dump__free(d);
857 	btf__free(btf);
858 }
859 
860 void test_btf_dump() {
861 	char str[STRSIZE];
862 	struct btf_dump *d;
863 	struct btf *btf;
864 	int i;
865 
866 	for (i = 0; i < ARRAY_SIZE(btf_dump_test_cases); i++) {
867 		struct btf_dump_test_case *t = &btf_dump_test_cases[i];
868 
869 		if (!test__start_subtest(t->name))
870 			continue;
871 
872 		test_btf_dump_case(i, &btf_dump_test_cases[i]);
873 	}
874 	if (test__start_subtest("btf_dump: incremental"))
875 		test_btf_dump_incremental();
876 
877 	btf = libbpf_find_kernel_btf();
878 	if (!ASSERT_OK_PTR(btf, "no kernel BTF found"))
879 		return;
880 
881 	d = btf_dump__new(btf, btf_dump_snprintf, str, NULL);
882 	if (!ASSERT_OK_PTR(d, "could not create BTF dump"))
883 		return;
884 
885 	/* Verify type display for various types. */
886 	if (test__start_subtest("btf_dump: int_data"))
887 		test_btf_dump_int_data(btf, d, str);
888 	if (test__start_subtest("btf_dump: float_data"))
889 		test_btf_dump_float_data(btf, d, str);
890 	if (test__start_subtest("btf_dump: char_data"))
891 		test_btf_dump_char_data(btf, d, str);
892 	if (test__start_subtest("btf_dump: typedef_data"))
893 		test_btf_dump_typedef_data(btf, d, str);
894 	if (test__start_subtest("btf_dump: enum_data"))
895 		test_btf_dump_enum_data(btf, d, str);
896 	if (test__start_subtest("btf_dump: struct_data"))
897 		test_btf_dump_struct_data(btf, d, str);
898 	if (test__start_subtest("btf_dump: var_data"))
899 		test_btf_dump_var_data(btf, d, str);
900 	btf_dump__free(d);
901 	btf__free(btf);
902 
903 	if (test__start_subtest("btf_dump: datasec_data"))
904 		test_btf_dump_datasec_data(str);
905 }
906