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
9static 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
32static 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
39static 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
55static 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
67static 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
81static 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
88int 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 */
216const 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
234int 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
249static 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 */
257const 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;
288err_out:
289 btf_dump__free(d);
290 fclose(buf_file);
291 return NULL;
292}
293

source code of linux/tools/testing/selftests/bpf/btf_helpers.c