1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2020 Facebook */
3 #include <stdio.h>
4 #include <errno.h>
5 #include <bpf/btf.h>
6 #include <bpf/libbpf.h>
7 #include "test_progs.h"
8 
9 static const char * const btf_kind_str_mapping[] = {
10 	[BTF_KIND_UNKN]		= "UNKNOWN",
11 	[BTF_KIND_INT]		= "INT",
12 	[BTF_KIND_PTR]		= "PTR",
13 	[BTF_KIND_ARRAY]	= "ARRAY",
14 	[BTF_KIND_STRUCT]	= "STRUCT",
15 	[BTF_KIND_UNION]	= "UNION",
16 	[BTF_KIND_ENUM]		= "ENUM",
17 	[BTF_KIND_FWD]		= "FWD",
18 	[BTF_KIND_TYPEDEF]	= "TYPEDEF",
19 	[BTF_KIND_VOLATILE]	= "VOLATILE",
20 	[BTF_KIND_CONST]	= "CONST",
21 	[BTF_KIND_RESTRICT]	= "RESTRICT",
22 	[BTF_KIND_FUNC]		= "FUNC",
23 	[BTF_KIND_FUNC_PROTO]	= "FUNC_PROTO",
24 	[BTF_KIND_VAR]		= "VAR",
25 	[BTF_KIND_DATASEC]	= "DATASEC",
26 	[BTF_KIND_FLOAT]	= "FLOAT",
27 	[BTF_KIND_DECL_TAG]	= "DECL_TAG",
28 	[BTF_KIND_TYPE_TAG]	= "TYPE_TAG",
29 	[BTF_KIND_ENUM64]	= "ENUM64",
30 };
31 
32 static const char *btf_kind_str(__u16 kind)
33 {
34 	if (kind > BTF_KIND_ENUM64)
35 		return "UNKNOWN";
36 	return btf_kind_str_mapping[kind];
37 }
38 
39 static const char *btf_int_enc_str(__u8 encoding)
40 {
41 	switch (encoding) {
42 	case 0:
43 		return "(none)";
44 	case BTF_INT_SIGNED:
45 		return "SIGNED";
46 	case BTF_INT_CHAR:
47 		return "CHAR";
48 	case BTF_INT_BOOL:
49 		return "BOOL";
50 	default:
51 		return "UNKN";
52 	}
53 }
54 
55 static const char *btf_var_linkage_str(__u32 linkage)
56 {
57 	switch (linkage) {
58 	case BTF_VAR_STATIC:
59 		return "static";
60 	case BTF_VAR_GLOBAL_ALLOCATED:
61 		return "global-alloc";
62 	default:
63 		return "(unknown)";
64 	}
65 }
66 
67 static const char *btf_func_linkage_str(const struct btf_type *t)
68 {
69 	switch (btf_vlen(t)) {
70 	case BTF_FUNC_STATIC:
71 		return "static";
72 	case BTF_FUNC_GLOBAL:
73 		return "global";
74 	case BTF_FUNC_EXTERN:
75 		return "extern";
76 	default:
77 		return "(unknown)";
78 	}
79 }
80 
81 static const char *btf_str(const struct btf *btf, __u32 off)
82 {
83 	if (!off)
84 		return "(anon)";
85 	return btf__str_by_offset(btf, off) ?: "(invalid)";
86 }
87 
88 int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id)
89 {
90 	const struct btf_type *t;
91 	int kind, i;
92 	__u32 vlen;
93 
94 	t = btf__type_by_id(btf, id);
95 	if (!t)
96 		return -EINVAL;
97 
98 	vlen = btf_vlen(t);
99 	kind = btf_kind(t);
100 
101 	fprintf(out, "[%u] %s '%s'", id, btf_kind_str(kind), btf_str(btf, t->name_off));
102 
103 	switch (kind) {
104 	case BTF_KIND_INT:
105 		fprintf(out, " size=%u bits_offset=%u nr_bits=%u encoding=%s",
106 			t->size, btf_int_offset(t), btf_int_bits(t),
107 			btf_int_enc_str(btf_int_encoding(t)));
108 		break;
109 	case BTF_KIND_PTR:
110 	case BTF_KIND_CONST:
111 	case BTF_KIND_VOLATILE:
112 	case BTF_KIND_RESTRICT:
113 	case BTF_KIND_TYPEDEF:
114 	case BTF_KIND_TYPE_TAG:
115 		fprintf(out, " type_id=%u", t->type);
116 		break;
117 	case BTF_KIND_ARRAY: {
118 		const struct btf_array *arr = btf_array(t);
119 
120 		fprintf(out, " type_id=%u index_type_id=%u nr_elems=%u",
121 			arr->type, arr->index_type, arr->nelems);
122 		break;
123 	}
124 	case BTF_KIND_STRUCT:
125 	case BTF_KIND_UNION: {
126 		const struct btf_member *m = btf_members(t);
127 
128 		fprintf(out, " size=%u vlen=%u", t->size, vlen);
129 		for (i = 0; i < vlen; i++, m++) {
130 			__u32 bit_off, bit_sz;
131 
132 			bit_off = btf_member_bit_offset(t, i);
133 			bit_sz = btf_member_bitfield_size(t, i);
134 			fprintf(out, "\n\t'%s' type_id=%u bits_offset=%u",
135 				btf_str(btf, m->name_off), m->type, bit_off);
136 			if (bit_sz)
137 				fprintf(out, " bitfield_size=%u", bit_sz);
138 		}
139 		break;
140 	}
141 	case BTF_KIND_ENUM: {
142 		const struct btf_enum *v = btf_enum(t);
143 		const char *fmt_str;
144 
145 		fmt_str = btf_kflag(t) ? "\n\t'%s' val=%d" : "\n\t'%s' val=%u";
146 		fprintf(out, " encoding=%s size=%u vlen=%u",
147 			btf_kflag(t) ? "SIGNED" : "UNSIGNED", t->size, vlen);
148 		for (i = 0; i < vlen; i++, v++) {
149 			fprintf(out, fmt_str,
150 				btf_str(btf, v->name_off), v->val);
151 		}
152 		break;
153 	}
154 	case BTF_KIND_ENUM64: {
155 		const struct btf_enum64 *v = btf_enum64(t);
156 		const char *fmt_str;
157 
158 		fmt_str = btf_kflag(t) ? "\n\t'%s' val=%lld" : "\n\t'%s' val=%llu";
159 
160 		fprintf(out, " encoding=%s size=%u vlen=%u",
161 			btf_kflag(t) ? "SIGNED" : "UNSIGNED", t->size, vlen);
162 		for (i = 0; i < vlen; i++, v++) {
163 			fprintf(out, fmt_str,
164 				btf_str(btf, v->name_off),
165 				((__u64)v->val_hi32 << 32) | v->val_lo32);
166 		}
167 		break;
168 	}
169 	case BTF_KIND_FWD:
170 		fprintf(out, " fwd_kind=%s", btf_kflag(t) ? "union" : "struct");
171 		break;
172 	case BTF_KIND_FUNC:
173 		fprintf(out, " type_id=%u linkage=%s", t->type, btf_func_linkage_str(t));
174 		break;
175 	case BTF_KIND_FUNC_PROTO: {
176 		const struct btf_param *p = btf_params(t);
177 
178 		fprintf(out, " ret_type_id=%u vlen=%u", t->type, vlen);
179 		for (i = 0; i < vlen; i++, p++) {
180 			fprintf(out, "\n\t'%s' type_id=%u",
181 				btf_str(btf, p->name_off), p->type);
182 		}
183 		break;
184 	}
185 	case BTF_KIND_VAR:
186 		fprintf(out, " type_id=%u, linkage=%s",
187 			t->type, btf_var_linkage_str(btf_var(t)->linkage));
188 		break;
189 	case BTF_KIND_DATASEC: {
190 		const struct btf_var_secinfo *v = btf_var_secinfos(t);
191 
192 		fprintf(out, " size=%u vlen=%u", t->size, vlen);
193 		for (i = 0; i < vlen; i++, v++) {
194 			fprintf(out, "\n\ttype_id=%u offset=%u size=%u",
195 				v->type, v->offset, v->size);
196 		}
197 		break;
198 	}
199 	case BTF_KIND_FLOAT:
200 		fprintf(out, " size=%u", t->size);
201 		break;
202 	case BTF_KIND_DECL_TAG:
203 		fprintf(out, " type_id=%u component_idx=%d",
204 			t->type, btf_decl_tag(t)->component_idx);
205 		break;
206 	default:
207 		break;
208 	}
209 
210 	return 0;
211 }
212 
213 /* Print raw BTF type dump into a local buffer and return string pointer back.
214  * Buffer *will* be overwritten by subsequent btf_type_raw_dump() calls
215  */
216 const char *btf_type_raw_dump(const struct btf *btf, int type_id)
217 {
218 	static char buf[16 * 1024];
219 	FILE *buf_file;
220 
221 	buf_file = fmemopen(buf, sizeof(buf) - 1, "w");
222 	if (!buf_file) {
223 		fprintf(stderr, "Failed to open memstream: %d\n", errno);
224 		return NULL;
225 	}
226 
227 	fprintf_btf_type_raw(buf_file, btf, type_id);
228 	fflush(buf_file);
229 	fclose(buf_file);
230 
231 	return buf;
232 }
233 
234 int btf_validate_raw(struct btf *btf, int nr_types, const char *exp_types[])
235 {
236 	int i;
237 	bool ok = true;
238 
239 	ASSERT_EQ(btf__type_cnt(btf) - 1, nr_types, "btf_nr_types");
240 
241 	for (i = 1; i <= nr_types; i++) {
242 		if (!ASSERT_STREQ(btf_type_raw_dump(btf, i), exp_types[i - 1], "raw_dump"))
243 			ok = false;
244 	}
245 
246 	return ok;
247 }
248 
249 static void btf_dump_printf(void *ctx, const char *fmt, va_list args)
250 {
251 	vfprintf(ctx, fmt, args);
252 }
253 
254 /* Print BTF-to-C dump into a local buffer and return string pointer back.
255  * Buffer *will* be overwritten by subsequent btf_type_raw_dump() calls
256  */
257 const char *btf_type_c_dump(const struct btf *btf)
258 {
259 	static char buf[16 * 1024];
260 	FILE *buf_file;
261 	struct btf_dump *d = NULL;
262 	int err, i;
263 
264 	buf_file = fmemopen(buf, sizeof(buf) - 1, "w");
265 	if (!buf_file) {
266 		fprintf(stderr, "Failed to open memstream: %d\n", errno);
267 		return NULL;
268 	}
269 
270 	d = btf_dump__new(btf, btf_dump_printf, buf_file, NULL);
271 	if (libbpf_get_error(d)) {
272 		fprintf(stderr, "Failed to create btf_dump instance: %ld\n", libbpf_get_error(d));
273 		goto err_out;
274 	}
275 
276 	for (i = 1; i < btf__type_cnt(btf); i++) {
277 		err = btf_dump__dump_type(d, i);
278 		if (err) {
279 			fprintf(stderr, "Failed to dump type [%d]: %d\n", i, err);
280 			goto err_out;
281 		}
282 	}
283 
284 	btf_dump__free(d);
285 	fflush(buf_file);
286 	fclose(buf_file);
287 	return buf;
288 err_out:
289 	btf_dump__free(d);
290 	fclose(buf_file);
291 	return NULL;
292 }
293