1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (c) 2018 Facebook */
3
4 #include <ctype.h>
5 #include <stdio.h> /* for (FILE *) used by json_writer */
6 #include <string.h>
7 #include <unistd.h>
8 #include <asm/byteorder.h>
9 #include <linux/bitops.h>
10 #include <linux/btf.h>
11 #include <linux/err.h>
12 #include <bpf/btf.h>
13 #include <bpf/bpf.h>
14
15 #include "json_writer.h"
16 #include "main.h"
17
18 #define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)
19 #define BITS_PER_BYTE_MASKED(bits) ((bits) & BITS_PER_BYTE_MASK)
20 #define BITS_ROUNDDOWN_BYTES(bits) ((bits) >> 3)
21 #define BITS_ROUNDUP_BYTES(bits) \
22 (BITS_ROUNDDOWN_BYTES(bits) + !!BITS_PER_BYTE_MASKED(bits))
23
24 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
25 __u8 bit_offset, const void *data);
26
27 static int btf_dump_func(const struct btf *btf, char *func_sig,
28 const struct btf_type *func_proto,
29 const struct btf_type *func, int pos, int size);
30
dump_prog_id_as_func_ptr(const struct btf_dumper * d,const struct btf_type * func_proto,__u32 prog_id)31 static int dump_prog_id_as_func_ptr(const struct btf_dumper *d,
32 const struct btf_type *func_proto,
33 __u32 prog_id)
34 {
35 const struct btf_type *func_type;
36 int prog_fd = -1, func_sig_len;
37 struct bpf_prog_info info = {};
38 __u32 info_len = sizeof(info);
39 const char *prog_name = NULL;
40 struct btf *prog_btf = NULL;
41 struct bpf_func_info finfo;
42 __u32 finfo_rec_size;
43 char prog_str[1024];
44 int err;
45
46 /* Get the ptr's func_proto */
47 func_sig_len = btf_dump_func(d->btf, prog_str, func_proto, NULL, 0,
48 sizeof(prog_str));
49 if (func_sig_len == -1)
50 return -1;
51
52 if (!prog_id)
53 goto print;
54
55 /* Get the bpf_prog's name. Obtain from func_info. */
56 prog_fd = bpf_prog_get_fd_by_id(prog_id);
57 if (prog_fd < 0)
58 goto print;
59
60 err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
61 if (err)
62 goto print;
63
64 if (!info.btf_id || !info.nr_func_info)
65 goto print;
66
67 finfo_rec_size = info.func_info_rec_size;
68 memset(&info, 0, sizeof(info));
69 info.nr_func_info = 1;
70 info.func_info_rec_size = finfo_rec_size;
71 info.func_info = ptr_to_u64(&finfo);
72
73 err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len);
74 if (err)
75 goto print;
76
77 prog_btf = btf__load_from_kernel_by_id(info.btf_id);
78 if (libbpf_get_error(prog_btf))
79 goto print;
80 func_type = btf__type_by_id(prog_btf, finfo.type_id);
81 if (!func_type || !btf_is_func(func_type))
82 goto print;
83
84 prog_name = btf__name_by_offset(prog_btf, func_type->name_off);
85
86 print:
87 if (!prog_id)
88 snprintf(&prog_str[func_sig_len],
89 sizeof(prog_str) - func_sig_len, " 0");
90 else if (prog_name)
91 snprintf(&prog_str[func_sig_len],
92 sizeof(prog_str) - func_sig_len,
93 " %s/prog_id:%u", prog_name, prog_id);
94 else
95 snprintf(&prog_str[func_sig_len],
96 sizeof(prog_str) - func_sig_len,
97 " <unknown_prog_name>/prog_id:%u", prog_id);
98
99 prog_str[sizeof(prog_str) - 1] = '\0';
100 jsonw_string(d->jw, prog_str);
101 btf__free(prog_btf);
102 if (prog_fd >= 0)
103 close(prog_fd);
104 return 0;
105 }
106
btf_dumper_ptr(const struct btf_dumper * d,const struct btf_type * t,const void * data)107 static void btf_dumper_ptr(const struct btf_dumper *d,
108 const struct btf_type *t,
109 const void *data)
110 {
111 unsigned long value = *(unsigned long *)data;
112 const struct btf_type *ptr_type;
113 __s32 ptr_type_id;
114
115 if (!d->prog_id_as_func_ptr || value > UINT32_MAX)
116 goto print_ptr_value;
117
118 ptr_type_id = btf__resolve_type(d->btf, t->type);
119 if (ptr_type_id < 0)
120 goto print_ptr_value;
121 ptr_type = btf__type_by_id(d->btf, ptr_type_id);
122 if (!ptr_type || !btf_is_func_proto(ptr_type))
123 goto print_ptr_value;
124
125 if (!dump_prog_id_as_func_ptr(d, ptr_type, value))
126 return;
127
128 print_ptr_value:
129 if (d->is_plain_text)
130 jsonw_printf(d->jw, "%p", (void *)value);
131 else
132 jsonw_printf(d->jw, "%lu", value);
133 }
134
btf_dumper_modifier(const struct btf_dumper * d,__u32 type_id,__u8 bit_offset,const void * data)135 static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,
136 __u8 bit_offset, const void *data)
137 {
138 int actual_type_id;
139
140 actual_type_id = btf__resolve_type(d->btf, type_id);
141 if (actual_type_id < 0)
142 return actual_type_id;
143
144 return btf_dumper_do_type(d, actual_type_id, bit_offset, data);
145 }
146
btf_dumper_enum(const struct btf_dumper * d,const struct btf_type * t,const void * data)147 static int btf_dumper_enum(const struct btf_dumper *d,
148 const struct btf_type *t,
149 const void *data)
150 {
151 const struct btf_enum *enums = btf_enum(t);
152 __s64 value;
153 __u16 i;
154
155 switch (t->size) {
156 case 8:
157 value = *(__s64 *)data;
158 break;
159 case 4:
160 value = *(__s32 *)data;
161 break;
162 case 2:
163 value = *(__s16 *)data;
164 break;
165 case 1:
166 value = *(__s8 *)data;
167 break;
168 default:
169 return -EINVAL;
170 }
171
172 for (i = 0; i < btf_vlen(t); i++) {
173 if (value == enums[i].val) {
174 jsonw_string(d->jw,
175 btf__name_by_offset(d->btf,
176 enums[i].name_off));
177 return 0;
178 }
179 }
180
181 jsonw_int(d->jw, value);
182 return 0;
183 }
184
is_str_array(const struct btf * btf,const struct btf_array * arr,const char * s)185 static bool is_str_array(const struct btf *btf, const struct btf_array *arr,
186 const char *s)
187 {
188 const struct btf_type *elem_type;
189 const char *end_s;
190
191 if (!arr->nelems)
192 return false;
193
194 elem_type = btf__type_by_id(btf, arr->type);
195 /* Not skipping typedef. typedef to char does not count as
196 * a string now.
197 */
198 while (elem_type && btf_is_mod(elem_type))
199 elem_type = btf__type_by_id(btf, elem_type->type);
200
201 if (!elem_type || !btf_is_int(elem_type) || elem_type->size != 1)
202 return false;
203
204 if (btf_int_encoding(elem_type) != BTF_INT_CHAR &&
205 strcmp("char", btf__name_by_offset(btf, elem_type->name_off)))
206 return false;
207
208 end_s = s + arr->nelems;
209 while (s < end_s) {
210 if (!*s)
211 return true;
212 if (*s <= 0x1f || *s >= 0x7f)
213 return false;
214 s++;
215 }
216
217 /* '\0' is not found */
218 return false;
219 }
220
btf_dumper_array(const struct btf_dumper * d,__u32 type_id,const void * data)221 static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,
222 const void *data)
223 {
224 const struct btf_type *t = btf__type_by_id(d->btf, type_id);
225 struct btf_array *arr = (struct btf_array *)(t + 1);
226 long long elem_size;
227 int ret = 0;
228 __u32 i;
229
230 if (is_str_array(d->btf, arr, data)) {
231 jsonw_string(d->jw, data);
232 return 0;
233 }
234
235 elem_size = btf__resolve_size(d->btf, arr->type);
236 if (elem_size < 0)
237 return elem_size;
238
239 jsonw_start_array(d->jw);
240 for (i = 0; i < arr->nelems; i++) {
241 ret = btf_dumper_do_type(d, arr->type, 0,
242 data + i * elem_size);
243 if (ret)
244 break;
245 }
246
247 jsonw_end_array(d->jw);
248 return ret;
249 }
250
btf_int128_print(json_writer_t * jw,const void * data,bool is_plain_text)251 static void btf_int128_print(json_writer_t *jw, const void *data,
252 bool is_plain_text)
253 {
254 /* data points to a __int128 number.
255 * Suppose
256 * int128_num = *(__int128 *)data;
257 * The below formulas shows what upper_num and lower_num represents:
258 * upper_num = int128_num >> 64;
259 * lower_num = int128_num & 0xffffffffFFFFFFFFULL;
260 */
261 __u64 upper_num, lower_num;
262
263 #ifdef __BIG_ENDIAN_BITFIELD
264 upper_num = *(__u64 *)data;
265 lower_num = *(__u64 *)(data + 8);
266 #else
267 upper_num = *(__u64 *)(data + 8);
268 lower_num = *(__u64 *)data;
269 #endif
270
271 if (is_plain_text) {
272 if (upper_num == 0)
273 jsonw_printf(jw, "0x%llx", lower_num);
274 else
275 jsonw_printf(jw, "0x%llx%016llx", upper_num, lower_num);
276 } else {
277 if (upper_num == 0)
278 jsonw_printf(jw, "\"0x%llx\"", lower_num);
279 else
280 jsonw_printf(jw, "\"0x%llx%016llx\"", upper_num, lower_num);
281 }
282 }
283
btf_int128_shift(__u64 * print_num,__u16 left_shift_bits,__u16 right_shift_bits)284 static void btf_int128_shift(__u64 *print_num, __u16 left_shift_bits,
285 __u16 right_shift_bits)
286 {
287 __u64 upper_num, lower_num;
288
289 #ifdef __BIG_ENDIAN_BITFIELD
290 upper_num = print_num[0];
291 lower_num = print_num[1];
292 #else
293 upper_num = print_num[1];
294 lower_num = print_num[0];
295 #endif
296
297 /* shake out un-needed bits by shift/or operations */
298 if (left_shift_bits >= 64) {
299 upper_num = lower_num << (left_shift_bits - 64);
300 lower_num = 0;
301 } else {
302 upper_num = (upper_num << left_shift_bits) |
303 (lower_num >> (64 - left_shift_bits));
304 lower_num = lower_num << left_shift_bits;
305 }
306
307 if (right_shift_bits >= 64) {
308 lower_num = upper_num >> (right_shift_bits - 64);
309 upper_num = 0;
310 } else {
311 lower_num = (lower_num >> right_shift_bits) |
312 (upper_num << (64 - right_shift_bits));
313 upper_num = upper_num >> right_shift_bits;
314 }
315
316 #ifdef __BIG_ENDIAN_BITFIELD
317 print_num[0] = upper_num;
318 print_num[1] = lower_num;
319 #else
320 print_num[0] = lower_num;
321 print_num[1] = upper_num;
322 #endif
323 }
324
btf_dumper_bitfield(__u32 nr_bits,__u8 bit_offset,const void * data,json_writer_t * jw,bool is_plain_text)325 static void btf_dumper_bitfield(__u32 nr_bits, __u8 bit_offset,
326 const void *data, json_writer_t *jw,
327 bool is_plain_text)
328 {
329 int left_shift_bits, right_shift_bits;
330 __u64 print_num[2] = {};
331 int bytes_to_copy;
332 int bits_to_copy;
333
334 bits_to_copy = bit_offset + nr_bits;
335 bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
336
337 memcpy(print_num, data, bytes_to_copy);
338 #if defined(__BIG_ENDIAN_BITFIELD)
339 left_shift_bits = bit_offset;
340 #elif defined(__LITTLE_ENDIAN_BITFIELD)
341 left_shift_bits = 128 - bits_to_copy;
342 #else
343 #error neither big nor little endian
344 #endif
345 right_shift_bits = 128 - nr_bits;
346
347 btf_int128_shift(print_num, left_shift_bits, right_shift_bits);
348 btf_int128_print(jw, print_num, is_plain_text);
349 }
350
351
btf_dumper_int_bits(__u32 int_type,__u8 bit_offset,const void * data,json_writer_t * jw,bool is_plain_text)352 static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
353 const void *data, json_writer_t *jw,
354 bool is_plain_text)
355 {
356 int nr_bits = BTF_INT_BITS(int_type);
357 int total_bits_offset;
358
359 /* bits_offset is at most 7.
360 * BTF_INT_OFFSET() cannot exceed 128 bits.
361 */
362 total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
363 data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
364 bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
365 btf_dumper_bitfield(nr_bits, bit_offset, data, jw,
366 is_plain_text);
367 }
368
btf_dumper_int(const struct btf_type * t,__u8 bit_offset,const void * data,json_writer_t * jw,bool is_plain_text)369 static int btf_dumper_int(const struct btf_type *t, __u8 bit_offset,
370 const void *data, json_writer_t *jw,
371 bool is_plain_text)
372 {
373 __u32 *int_type;
374 __u32 nr_bits;
375
376 int_type = (__u32 *)(t + 1);
377 nr_bits = BTF_INT_BITS(*int_type);
378 /* if this is bit field */
379 if (bit_offset || BTF_INT_OFFSET(*int_type) ||
380 BITS_PER_BYTE_MASKED(nr_bits)) {
381 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
382 is_plain_text);
383 return 0;
384 }
385
386 if (nr_bits == 128) {
387 btf_int128_print(jw, data, is_plain_text);
388 return 0;
389 }
390
391 switch (BTF_INT_ENCODING(*int_type)) {
392 case 0:
393 if (BTF_INT_BITS(*int_type) == 64)
394 jsonw_printf(jw, "%llu", *(__u64 *)data);
395 else if (BTF_INT_BITS(*int_type) == 32)
396 jsonw_printf(jw, "%u", *(__u32 *)data);
397 else if (BTF_INT_BITS(*int_type) == 16)
398 jsonw_printf(jw, "%hu", *(__u16 *)data);
399 else if (BTF_INT_BITS(*int_type) == 8)
400 jsonw_printf(jw, "%hhu", *(__u8 *)data);
401 else
402 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
403 is_plain_text);
404 break;
405 case BTF_INT_SIGNED:
406 if (BTF_INT_BITS(*int_type) == 64)
407 jsonw_printf(jw, "%lld", *(long long *)data);
408 else if (BTF_INT_BITS(*int_type) == 32)
409 jsonw_printf(jw, "%d", *(int *)data);
410 else if (BTF_INT_BITS(*int_type) == 16)
411 jsonw_printf(jw, "%hd", *(short *)data);
412 else if (BTF_INT_BITS(*int_type) == 8)
413 jsonw_printf(jw, "%hhd", *(char *)data);
414 else
415 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
416 is_plain_text);
417 break;
418 case BTF_INT_CHAR:
419 if (isprint(*(char *)data))
420 jsonw_printf(jw, "\"%c\"", *(char *)data);
421 else
422 if (is_plain_text)
423 jsonw_printf(jw, "0x%hhx", *(char *)data);
424 else
425 jsonw_printf(jw, "\"\\u00%02hhx\"",
426 *(char *)data);
427 break;
428 case BTF_INT_BOOL:
429 jsonw_bool(jw, *(int *)data);
430 break;
431 default:
432 /* shouldn't happen */
433 return -EINVAL;
434 }
435
436 return 0;
437 }
438
btf_dumper_struct(const struct btf_dumper * d,__u32 type_id,const void * data)439 static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
440 const void *data)
441 {
442 const struct btf_type *t;
443 struct btf_member *m;
444 const void *data_off;
445 int kind_flag;
446 int ret = 0;
447 int i, vlen;
448
449 t = btf__type_by_id(d->btf, type_id);
450 if (!t)
451 return -EINVAL;
452
453 kind_flag = BTF_INFO_KFLAG(t->info);
454 vlen = BTF_INFO_VLEN(t->info);
455 jsonw_start_object(d->jw);
456 m = (struct btf_member *)(t + 1);
457
458 for (i = 0; i < vlen; i++) {
459 __u32 bit_offset = m[i].offset;
460 __u32 bitfield_size = 0;
461
462 if (kind_flag) {
463 bitfield_size = BTF_MEMBER_BITFIELD_SIZE(bit_offset);
464 bit_offset = BTF_MEMBER_BIT_OFFSET(bit_offset);
465 }
466
467 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
468 data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
469 if (bitfield_size) {
470 btf_dumper_bitfield(bitfield_size,
471 BITS_PER_BYTE_MASKED(bit_offset),
472 data_off, d->jw, d->is_plain_text);
473 } else {
474 ret = btf_dumper_do_type(d, m[i].type,
475 BITS_PER_BYTE_MASKED(bit_offset),
476 data_off);
477 if (ret)
478 break;
479 }
480 }
481
482 jsonw_end_object(d->jw);
483
484 return ret;
485 }
486
btf_dumper_var(const struct btf_dumper * d,__u32 type_id,__u8 bit_offset,const void * data)487 static int btf_dumper_var(const struct btf_dumper *d, __u32 type_id,
488 __u8 bit_offset, const void *data)
489 {
490 const struct btf_type *t = btf__type_by_id(d->btf, type_id);
491 int ret;
492
493 jsonw_start_object(d->jw);
494 jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));
495 ret = btf_dumper_do_type(d, t->type, bit_offset, data);
496 jsonw_end_object(d->jw);
497
498 return ret;
499 }
500
btf_dumper_datasec(const struct btf_dumper * d,__u32 type_id,const void * data)501 static int btf_dumper_datasec(const struct btf_dumper *d, __u32 type_id,
502 const void *data)
503 {
504 struct btf_var_secinfo *vsi;
505 const struct btf_type *t;
506 int ret = 0, i, vlen;
507
508 t = btf__type_by_id(d->btf, type_id);
509 if (!t)
510 return -EINVAL;
511
512 vlen = BTF_INFO_VLEN(t->info);
513 vsi = (struct btf_var_secinfo *)(t + 1);
514
515 jsonw_start_object(d->jw);
516 jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));
517 jsonw_start_array(d->jw);
518 for (i = 0; i < vlen; i++) {
519 ret = btf_dumper_do_type(d, vsi[i].type, 0, data + vsi[i].offset);
520 if (ret)
521 break;
522 }
523 jsonw_end_array(d->jw);
524 jsonw_end_object(d->jw);
525
526 return ret;
527 }
528
btf_dumper_do_type(const struct btf_dumper * d,__u32 type_id,__u8 bit_offset,const void * data)529 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
530 __u8 bit_offset, const void *data)
531 {
532 const struct btf_type *t = btf__type_by_id(d->btf, type_id);
533
534 switch (BTF_INFO_KIND(t->info)) {
535 case BTF_KIND_INT:
536 return btf_dumper_int(t, bit_offset, data, d->jw,
537 d->is_plain_text);
538 case BTF_KIND_STRUCT:
539 case BTF_KIND_UNION:
540 return btf_dumper_struct(d, type_id, data);
541 case BTF_KIND_ARRAY:
542 return btf_dumper_array(d, type_id, data);
543 case BTF_KIND_ENUM:
544 return btf_dumper_enum(d, t, data);
545 case BTF_KIND_PTR:
546 btf_dumper_ptr(d, t, data);
547 return 0;
548 case BTF_KIND_UNKN:
549 jsonw_printf(d->jw, "(unknown)");
550 return 0;
551 case BTF_KIND_FWD:
552 /* map key or value can't be forward */
553 jsonw_printf(d->jw, "(fwd-kind-invalid)");
554 return -EINVAL;
555 case BTF_KIND_TYPEDEF:
556 case BTF_KIND_VOLATILE:
557 case BTF_KIND_CONST:
558 case BTF_KIND_RESTRICT:
559 return btf_dumper_modifier(d, type_id, bit_offset, data);
560 case BTF_KIND_VAR:
561 return btf_dumper_var(d, type_id, bit_offset, data);
562 case BTF_KIND_DATASEC:
563 return btf_dumper_datasec(d, type_id, data);
564 default:
565 jsonw_printf(d->jw, "(unsupported-kind");
566 return -EINVAL;
567 }
568 }
569
btf_dumper_type(const struct btf_dumper * d,__u32 type_id,const void * data)570 int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
571 const void *data)
572 {
573 return btf_dumper_do_type(d, type_id, 0, data);
574 }
575
576 #define BTF_PRINT_ARG(...) \
577 do { \
578 pos += snprintf(func_sig + pos, size - pos, \
579 __VA_ARGS__); \
580 if (pos >= size) \
581 return -1; \
582 } while (0)
583 #define BTF_PRINT_TYPE(type) \
584 do { \
585 pos = __btf_dumper_type_only(btf, type, func_sig, \
586 pos, size); \
587 if (pos == -1) \
588 return -1; \
589 } while (0)
590
__btf_dumper_type_only(const struct btf * btf,__u32 type_id,char * func_sig,int pos,int size)591 static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
592 char *func_sig, int pos, int size)
593 {
594 const struct btf_type *proto_type;
595 const struct btf_array *array;
596 const struct btf_var *var;
597 const struct btf_type *t;
598
599 if (!type_id) {
600 BTF_PRINT_ARG("void ");
601 return pos;
602 }
603
604 t = btf__type_by_id(btf, type_id);
605
606 switch (BTF_INFO_KIND(t->info)) {
607 case BTF_KIND_INT:
608 case BTF_KIND_TYPEDEF:
609 case BTF_KIND_FLOAT:
610 BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off));
611 break;
612 case BTF_KIND_STRUCT:
613 BTF_PRINT_ARG("struct %s ",
614 btf__name_by_offset(btf, t->name_off));
615 break;
616 case BTF_KIND_UNION:
617 BTF_PRINT_ARG("union %s ",
618 btf__name_by_offset(btf, t->name_off));
619 break;
620 case BTF_KIND_ENUM:
621 BTF_PRINT_ARG("enum %s ",
622 btf__name_by_offset(btf, t->name_off));
623 break;
624 case BTF_KIND_ARRAY:
625 array = (struct btf_array *)(t + 1);
626 BTF_PRINT_TYPE(array->type);
627 BTF_PRINT_ARG("[%d]", array->nelems);
628 break;
629 case BTF_KIND_PTR:
630 BTF_PRINT_TYPE(t->type);
631 BTF_PRINT_ARG("* ");
632 break;
633 case BTF_KIND_FWD:
634 BTF_PRINT_ARG("%s %s ",
635 BTF_INFO_KFLAG(t->info) ? "union" : "struct",
636 btf__name_by_offset(btf, t->name_off));
637 break;
638 case BTF_KIND_VOLATILE:
639 BTF_PRINT_ARG("volatile ");
640 BTF_PRINT_TYPE(t->type);
641 break;
642 case BTF_KIND_CONST:
643 BTF_PRINT_ARG("const ");
644 BTF_PRINT_TYPE(t->type);
645 break;
646 case BTF_KIND_RESTRICT:
647 BTF_PRINT_ARG("restrict ");
648 BTF_PRINT_TYPE(t->type);
649 break;
650 case BTF_KIND_FUNC_PROTO:
651 pos = btf_dump_func(btf, func_sig, t, NULL, pos, size);
652 if (pos == -1)
653 return -1;
654 break;
655 case BTF_KIND_FUNC:
656 proto_type = btf__type_by_id(btf, t->type);
657 pos = btf_dump_func(btf, func_sig, proto_type, t, pos, size);
658 if (pos == -1)
659 return -1;
660 break;
661 case BTF_KIND_VAR:
662 var = (struct btf_var *)(t + 1);
663 if (var->linkage == BTF_VAR_STATIC)
664 BTF_PRINT_ARG("static ");
665 BTF_PRINT_TYPE(t->type);
666 BTF_PRINT_ARG(" %s",
667 btf__name_by_offset(btf, t->name_off));
668 break;
669 case BTF_KIND_DATASEC:
670 BTF_PRINT_ARG("section (\"%s\") ",
671 btf__name_by_offset(btf, t->name_off));
672 break;
673 case BTF_KIND_UNKN:
674 default:
675 return -1;
676 }
677
678 return pos;
679 }
680
btf_dump_func(const struct btf * btf,char * func_sig,const struct btf_type * func_proto,const struct btf_type * func,int pos,int size)681 static int btf_dump_func(const struct btf *btf, char *func_sig,
682 const struct btf_type *func_proto,
683 const struct btf_type *func, int pos, int size)
684 {
685 int i, vlen;
686
687 BTF_PRINT_TYPE(func_proto->type);
688 if (func)
689 BTF_PRINT_ARG("%s(", btf__name_by_offset(btf, func->name_off));
690 else
691 BTF_PRINT_ARG("(");
692 vlen = BTF_INFO_VLEN(func_proto->info);
693 for (i = 0; i < vlen; i++) {
694 struct btf_param *arg = &((struct btf_param *)(func_proto + 1))[i];
695
696 if (i)
697 BTF_PRINT_ARG(", ");
698 if (arg->type) {
699 BTF_PRINT_TYPE(arg->type);
700 if (arg->name_off)
701 BTF_PRINT_ARG("%s",
702 btf__name_by_offset(btf, arg->name_off));
703 else if (pos && func_sig[pos - 1] == ' ')
704 /* Remove unnecessary space for
705 * FUNC_PROTO that does not have
706 * arg->name_off
707 */
708 func_sig[--pos] = '\0';
709 } else {
710 BTF_PRINT_ARG("...");
711 }
712 }
713 BTF_PRINT_ARG(")");
714
715 return pos;
716 }
717
btf_dumper_type_only(const struct btf * btf,__u32 type_id,char * func_sig,int size)718 void btf_dumper_type_only(const struct btf *btf, __u32 type_id, char *func_sig,
719 int size)
720 {
721 int err;
722
723 func_sig[0] = '\0';
724 if (!btf)
725 return;
726
727 err = __btf_dumper_type_only(btf, type_id, func_sig, 0, size);
728 if (err < 0)
729 func_sig[0] = '\0';
730 }
731
ltrim(const char * s)732 static const char *ltrim(const char *s)
733 {
734 while (isspace(*s))
735 s++;
736
737 return s;
738 }
739
btf_dump_linfo_plain(const struct btf * btf,const struct bpf_line_info * linfo,const char * prefix,bool linum)740 void btf_dump_linfo_plain(const struct btf *btf,
741 const struct bpf_line_info *linfo,
742 const char *prefix, bool linum)
743 {
744 const char *line = btf__name_by_offset(btf, linfo->line_off);
745
746 if (!line)
747 return;
748 line = ltrim(line);
749
750 if (!prefix)
751 prefix = "";
752
753 if (linum) {
754 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
755
756 /* More forgiving on file because linum option is
757 * expected to provide more info than the already
758 * available src line.
759 */
760 if (!file)
761 file = "";
762
763 printf("%s%s [file:%s line_num:%u line_col:%u]\n",
764 prefix, line, file,
765 BPF_LINE_INFO_LINE_NUM(linfo->line_col),
766 BPF_LINE_INFO_LINE_COL(linfo->line_col));
767 } else {
768 printf("%s%s\n", prefix, line);
769 }
770 }
771
btf_dump_linfo_json(const struct btf * btf,const struct bpf_line_info * linfo,bool linum)772 void btf_dump_linfo_json(const struct btf *btf,
773 const struct bpf_line_info *linfo, bool linum)
774 {
775 const char *line = btf__name_by_offset(btf, linfo->line_off);
776
777 if (line)
778 jsonw_string_field(json_wtr, "src", ltrim(line));
779
780 if (linum) {
781 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
782
783 if (file)
784 jsonw_string_field(json_wtr, "file", file);
785
786 if (BPF_LINE_INFO_LINE_NUM(linfo->line_col))
787 jsonw_int_field(json_wtr, "line_num",
788 BPF_LINE_INFO_LINE_NUM(linfo->line_col));
789
790 if (BPF_LINE_INFO_LINE_COL(linfo->line_col))
791 jsonw_int_field(json_wtr, "line_col",
792 BPF_LINE_INFO_LINE_COL(linfo->line_col));
793 }
794 }
795