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