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, off: 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(encoding: 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, member_idx: i); |
133 | bit_sz = btf_member_bitfield_size(t, member_idx: i); |
134 | fprintf(out, "\n\t'%s' type_id=%u bits_offset=%u" , |
135 | btf_str(btf, off: 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, off: 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, off: 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, off: 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(linkage: 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 | |