This source file includes following definitions.
- pfx
- str_hash_fn
- str_equal_fn
- btf_name_of
- btf_dump_printf
- btf_dump__new
- btf_dump__free
- btf_dump__dump_type
- btf_dump_mark_referenced
- btf_dump_add_emit_queue_id
- btf_dump_order_type
- btf_dump_is_blacklisted
- btf_dump_emit_type
- btf_align_of
- btf_is_struct_packed
- chip_away_bits
- btf_dump_emit_bit_padding
- btf_dump_emit_struct_fwd
- btf_dump_emit_struct_def
- btf_dump_emit_enum_fwd
- btf_dump_emit_enum_def
- btf_dump_emit_fwd_def
- btf_dump_emit_typedef_def
- btf_dump_push_decl_stack_id
- btf_dump_emit_type_decl
- btf_dump_emit_mods
- btf_dump_emit_name
- btf_dump_emit_type_chain
- btf_dump_name_dups
- btf_dump_resolve_name
- btf_dump_type_name
- btf_dump_ident_name
1
2
3
4
5
6
7
8
9 #include <stdbool.h>
10 #include <stddef.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <errno.h>
14 #include <linux/err.h>
15 #include <linux/btf.h>
16 #include "btf.h"
17 #include "hashmap.h"
18 #include "libbpf.h"
19 #include "libbpf_internal.h"
20
21 static const char PREFIXES[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t";
22 static const size_t PREFIX_CNT = sizeof(PREFIXES) - 1;
23
24 static const char *pfx(int lvl)
25 {
26 return lvl >= PREFIX_CNT ? PREFIXES : &PREFIXES[PREFIX_CNT - lvl];
27 }
28
29 enum btf_dump_type_order_state {
30 NOT_ORDERED,
31 ORDERING,
32 ORDERED,
33 };
34
35 enum btf_dump_type_emit_state {
36 NOT_EMITTED,
37 EMITTING,
38 EMITTED,
39 };
40
41
42 struct btf_dump_type_aux_state {
43
44 enum btf_dump_type_order_state order_state: 2;
45
46 enum btf_dump_type_emit_state emit_state: 2;
47
48 __u8 fwd_emitted: 1;
49
50 __u8 name_resolved: 1;
51
52 __u8 referenced: 1;
53 };
54
55 struct btf_dump {
56 const struct btf *btf;
57 const struct btf_ext *btf_ext;
58 btf_dump_printf_fn_t printf_fn;
59 struct btf_dump_opts opts;
60
61
62 struct btf_dump_type_aux_state *type_states;
63
64 const char **cached_names;
65
66
67 __u32 *emit_queue;
68 int emit_queue_cap;
69 int emit_queue_cnt;
70
71
72
73
74
75 __u32 *decl_stack;
76 int decl_stack_cap;
77 int decl_stack_cnt;
78
79
80 struct hashmap *type_names;
81
82
83
84
85 struct hashmap *ident_names;
86 };
87
88 static size_t str_hash_fn(const void *key, void *ctx)
89 {
90 const char *s = key;
91 size_t h = 0;
92
93 while (*s) {
94 h = h * 31 + *s;
95 s++;
96 }
97 return h;
98 }
99
100 static bool str_equal_fn(const void *a, const void *b, void *ctx)
101 {
102 return strcmp(a, b) == 0;
103 }
104
105 static const char *btf_name_of(const struct btf_dump *d, __u32 name_off)
106 {
107 return btf__name_by_offset(d->btf, name_off);
108 }
109
110 static void btf_dump_printf(const struct btf_dump *d, const char *fmt, ...)
111 {
112 va_list args;
113
114 va_start(args, fmt);
115 d->printf_fn(d->opts.ctx, fmt, args);
116 va_end(args);
117 }
118
119 struct btf_dump *btf_dump__new(const struct btf *btf,
120 const struct btf_ext *btf_ext,
121 const struct btf_dump_opts *opts,
122 btf_dump_printf_fn_t printf_fn)
123 {
124 struct btf_dump *d;
125 int err;
126
127 d = calloc(1, sizeof(struct btf_dump));
128 if (!d)
129 return ERR_PTR(-ENOMEM);
130
131 d->btf = btf;
132 d->btf_ext = btf_ext;
133 d->printf_fn = printf_fn;
134 d->opts.ctx = opts ? opts->ctx : NULL;
135
136 d->type_names = hashmap__new(str_hash_fn, str_equal_fn, NULL);
137 if (IS_ERR(d->type_names)) {
138 err = PTR_ERR(d->type_names);
139 d->type_names = NULL;
140 btf_dump__free(d);
141 return ERR_PTR(err);
142 }
143 d->ident_names = hashmap__new(str_hash_fn, str_equal_fn, NULL);
144 if (IS_ERR(d->ident_names)) {
145 err = PTR_ERR(d->ident_names);
146 d->ident_names = NULL;
147 btf_dump__free(d);
148 return ERR_PTR(err);
149 }
150
151 return d;
152 }
153
154 void btf_dump__free(struct btf_dump *d)
155 {
156 int i, cnt;
157
158 if (!d)
159 return;
160
161 free(d->type_states);
162 if (d->cached_names) {
163
164 for (i = 0, cnt = btf__get_nr_types(d->btf); i <= cnt; i++) {
165 if (d->cached_names[i])
166 free((void *)d->cached_names[i]);
167 }
168 }
169 free(d->cached_names);
170 free(d->emit_queue);
171 free(d->decl_stack);
172 hashmap__free(d->type_names);
173 hashmap__free(d->ident_names);
174
175 free(d);
176 }
177
178 static int btf_dump_mark_referenced(struct btf_dump *d);
179 static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr);
180 static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id);
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198 int btf_dump__dump_type(struct btf_dump *d, __u32 id)
199 {
200 int err, i;
201
202 if (id > btf__get_nr_types(d->btf))
203 return -EINVAL;
204
205
206 if (!d->type_states) {
207 d->type_states = calloc(1 + btf__get_nr_types(d->btf),
208 sizeof(d->type_states[0]));
209 if (!d->type_states)
210 return -ENOMEM;
211 d->cached_names = calloc(1 + btf__get_nr_types(d->btf),
212 sizeof(d->cached_names[0]));
213 if (!d->cached_names)
214 return -ENOMEM;
215
216
217 d->type_states[0].order_state = ORDERED;
218 d->type_states[0].emit_state = EMITTED;
219
220
221 err = btf_dump_mark_referenced(d);
222 if (err)
223 return err;
224 }
225
226 d->emit_queue_cnt = 0;
227 err = btf_dump_order_type(d, id, false);
228 if (err < 0)
229 return err;
230
231 for (i = 0; i < d->emit_queue_cnt; i++)
232 btf_dump_emit_type(d, d->emit_queue[i], 0 );
233
234 return 0;
235 }
236
237
238
239
240
241
242
243
244
245
246
247
248
249 static int btf_dump_mark_referenced(struct btf_dump *d)
250 {
251 int i, j, n = btf__get_nr_types(d->btf);
252 const struct btf_type *t;
253 __u16 vlen;
254
255 for (i = 1; i <= n; i++) {
256 t = btf__type_by_id(d->btf, i);
257 vlen = btf_vlen(t);
258
259 switch (btf_kind(t)) {
260 case BTF_KIND_INT:
261 case BTF_KIND_ENUM:
262 case BTF_KIND_FWD:
263 break;
264
265 case BTF_KIND_VOLATILE:
266 case BTF_KIND_CONST:
267 case BTF_KIND_RESTRICT:
268 case BTF_KIND_PTR:
269 case BTF_KIND_TYPEDEF:
270 case BTF_KIND_FUNC:
271 case BTF_KIND_VAR:
272 d->type_states[t->type].referenced = 1;
273 break;
274
275 case BTF_KIND_ARRAY: {
276 const struct btf_array *a = btf_array(t);
277
278 d->type_states[a->index_type].referenced = 1;
279 d->type_states[a->type].referenced = 1;
280 break;
281 }
282 case BTF_KIND_STRUCT:
283 case BTF_KIND_UNION: {
284 const struct btf_member *m = btf_members(t);
285
286 for (j = 0; j < vlen; j++, m++)
287 d->type_states[m->type].referenced = 1;
288 break;
289 }
290 case BTF_KIND_FUNC_PROTO: {
291 const struct btf_param *p = btf_params(t);
292
293 for (j = 0; j < vlen; j++, p++)
294 d->type_states[p->type].referenced = 1;
295 break;
296 }
297 case BTF_KIND_DATASEC: {
298 const struct btf_var_secinfo *v = btf_var_secinfos(t);
299
300 for (j = 0; j < vlen; j++, v++)
301 d->type_states[v->type].referenced = 1;
302 break;
303 }
304 default:
305 return -EINVAL;
306 }
307 }
308 return 0;
309 }
310 static int btf_dump_add_emit_queue_id(struct btf_dump *d, __u32 id)
311 {
312 __u32 *new_queue;
313 size_t new_cap;
314
315 if (d->emit_queue_cnt >= d->emit_queue_cap) {
316 new_cap = max(16, d->emit_queue_cap * 3 / 2);
317 new_queue = realloc(d->emit_queue,
318 new_cap * sizeof(new_queue[0]));
319 if (!new_queue)
320 return -ENOMEM;
321 d->emit_queue = new_queue;
322 d->emit_queue_cap = new_cap;
323 }
324
325 d->emit_queue[d->emit_queue_cnt++] = id;
326 return 0;
327 }
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403 static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)
404 {
405
406
407
408
409
410
411
412
413
414
415
416 struct btf_dump_type_aux_state *tstate = &d->type_states[id];
417 const struct btf_type *t;
418 __u16 vlen;
419 int err, i;
420
421
422 if (tstate->order_state == ORDERED)
423 return 1;
424
425 t = btf__type_by_id(d->btf, id);
426
427 if (tstate->order_state == ORDERING) {
428
429 if (btf_is_composite(t) && through_ptr && t->name_off != 0)
430 return 0;
431 pr_warning("unsatisfiable type cycle, id:[%u]\n", id);
432 return -ELOOP;
433 }
434
435 switch (btf_kind(t)) {
436 case BTF_KIND_INT:
437 tstate->order_state = ORDERED;
438 return 0;
439
440 case BTF_KIND_PTR:
441 err = btf_dump_order_type(d, t->type, true);
442 tstate->order_state = ORDERED;
443 return err;
444
445 case BTF_KIND_ARRAY:
446 return btf_dump_order_type(d, btf_array(t)->type, through_ptr);
447
448 case BTF_KIND_STRUCT:
449 case BTF_KIND_UNION: {
450 const struct btf_member *m = btf_members(t);
451
452
453
454
455
456 if (through_ptr && t->name_off != 0)
457 return 0;
458
459 tstate->order_state = ORDERING;
460
461 vlen = btf_vlen(t);
462 for (i = 0; i < vlen; i++, m++) {
463 err = btf_dump_order_type(d, m->type, false);
464 if (err < 0)
465 return err;
466 }
467
468 if (t->name_off != 0) {
469 err = btf_dump_add_emit_queue_id(d, id);
470 if (err < 0)
471 return err;
472 }
473
474 tstate->order_state = ORDERED;
475 return 1;
476 }
477 case BTF_KIND_ENUM:
478 case BTF_KIND_FWD:
479
480
481
482
483
484 if (t->name_off != 0 || !tstate->referenced) {
485 err = btf_dump_add_emit_queue_id(d, id);
486 if (err)
487 return err;
488 }
489 tstate->order_state = ORDERED;
490 return 1;
491
492 case BTF_KIND_TYPEDEF: {
493 int is_strong;
494
495 is_strong = btf_dump_order_type(d, t->type, through_ptr);
496 if (is_strong < 0)
497 return is_strong;
498
499
500 if (through_ptr && !is_strong)
501 return 0;
502
503
504 err = btf_dump_add_emit_queue_id(d, id);
505 if (err)
506 return err;
507
508 d->type_states[id].order_state = ORDERED;
509 return 1;
510 }
511 case BTF_KIND_VOLATILE:
512 case BTF_KIND_CONST:
513 case BTF_KIND_RESTRICT:
514 return btf_dump_order_type(d, t->type, through_ptr);
515
516 case BTF_KIND_FUNC_PROTO: {
517 const struct btf_param *p = btf_params(t);
518 bool is_strong;
519
520 err = btf_dump_order_type(d, t->type, through_ptr);
521 if (err < 0)
522 return err;
523 is_strong = err > 0;
524
525 vlen = btf_vlen(t);
526 for (i = 0; i < vlen; i++, p++) {
527 err = btf_dump_order_type(d, p->type, through_ptr);
528 if (err < 0)
529 return err;
530 if (err > 0)
531 is_strong = true;
532 }
533 return is_strong;
534 }
535 case BTF_KIND_FUNC:
536 case BTF_KIND_VAR:
537 case BTF_KIND_DATASEC:
538 d->type_states[id].order_state = ORDERED;
539 return 0;
540
541 default:
542 return -EINVAL;
543 }
544 }
545
546 static void btf_dump_emit_struct_fwd(struct btf_dump *d, __u32 id,
547 const struct btf_type *t);
548 static void btf_dump_emit_struct_def(struct btf_dump *d, __u32 id,
549 const struct btf_type *t, int lvl);
550
551 static void btf_dump_emit_enum_fwd(struct btf_dump *d, __u32 id,
552 const struct btf_type *t);
553 static void btf_dump_emit_enum_def(struct btf_dump *d, __u32 id,
554 const struct btf_type *t, int lvl);
555
556 static void btf_dump_emit_fwd_def(struct btf_dump *d, __u32 id,
557 const struct btf_type *t);
558
559 static void btf_dump_emit_typedef_def(struct btf_dump *d, __u32 id,
560 const struct btf_type *t, int lvl);
561
562
563 struct id_stack {
564 const __u32 *ids;
565 int cnt;
566 };
567
568 static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,
569 const char *fname, int lvl);
570 static void btf_dump_emit_type_chain(struct btf_dump *d,
571 struct id_stack *decl_stack,
572 const char *fname, int lvl);
573
574 static const char *btf_dump_type_name(struct btf_dump *d, __u32 id);
575 static const char *btf_dump_ident_name(struct btf_dump *d, __u32 id);
576 static size_t btf_dump_name_dups(struct btf_dump *d, struct hashmap *name_map,
577 const char *orig_name);
578
579 static bool btf_dump_is_blacklisted(struct btf_dump *d, __u32 id)
580 {
581 const struct btf_type *t = btf__type_by_id(d->btf, id);
582
583
584
585
586
587
588
589 if (t->name_off == 0)
590 return false;
591 return strcmp(btf_name_of(d, t->name_off), "__builtin_va_list") == 0;
592 }
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612 static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id)
613 {
614 struct btf_dump_type_aux_state *tstate = &d->type_states[id];
615 bool top_level_def = cont_id == 0;
616 const struct btf_type *t;
617 __u16 kind;
618
619 if (tstate->emit_state == EMITTED)
620 return;
621
622 t = btf__type_by_id(d->btf, id);
623 kind = btf_kind(t);
624
625 if (tstate->emit_state == EMITTING) {
626 if (tstate->fwd_emitted)
627 return;
628
629 switch (kind) {
630 case BTF_KIND_STRUCT:
631 case BTF_KIND_UNION:
632
633
634
635
636 if (id == cont_id)
637 return;
638 if (t->name_off == 0) {
639 pr_warning("anonymous struct/union loop, id:[%u]\n",
640 id);
641 return;
642 }
643 btf_dump_emit_struct_fwd(d, id, t);
644 btf_dump_printf(d, ";\n\n");
645 tstate->fwd_emitted = 1;
646 break;
647 case BTF_KIND_TYPEDEF:
648
649
650
651
652
653 if (!btf_dump_is_blacklisted(d, id)) {
654 btf_dump_emit_typedef_def(d, id, t, 0);
655 btf_dump_printf(d, ";\n\n");
656 };
657 tstate->fwd_emitted = 1;
658 break;
659 default:
660 break;
661 }
662
663 return;
664 }
665
666 switch (kind) {
667 case BTF_KIND_INT:
668 tstate->emit_state = EMITTED;
669 break;
670 case BTF_KIND_ENUM:
671 if (top_level_def) {
672 btf_dump_emit_enum_def(d, id, t, 0);
673 btf_dump_printf(d, ";\n\n");
674 }
675 tstate->emit_state = EMITTED;
676 break;
677 case BTF_KIND_PTR:
678 case BTF_KIND_VOLATILE:
679 case BTF_KIND_CONST:
680 case BTF_KIND_RESTRICT:
681 btf_dump_emit_type(d, t->type, cont_id);
682 break;
683 case BTF_KIND_ARRAY:
684 btf_dump_emit_type(d, btf_array(t)->type, cont_id);
685 break;
686 case BTF_KIND_FWD:
687 btf_dump_emit_fwd_def(d, id, t);
688 btf_dump_printf(d, ";\n\n");
689 tstate->emit_state = EMITTED;
690 break;
691 case BTF_KIND_TYPEDEF:
692 tstate->emit_state = EMITTING;
693 btf_dump_emit_type(d, t->type, id);
694
695
696
697
698
699
700
701 if (!tstate->fwd_emitted && !btf_dump_is_blacklisted(d, id)) {
702 btf_dump_emit_typedef_def(d, id, t, 0);
703 btf_dump_printf(d, ";\n\n");
704 }
705 tstate->emit_state = EMITTED;
706 break;
707 case BTF_KIND_STRUCT:
708 case BTF_KIND_UNION:
709 tstate->emit_state = EMITTING;
710
711
712
713
714
715
716
717 if (top_level_def || t->name_off == 0) {
718 const struct btf_member *m = btf_members(t);
719 __u16 vlen = btf_vlen(t);
720 int i, new_cont_id;
721
722 new_cont_id = t->name_off == 0 ? cont_id : id;
723 for (i = 0; i < vlen; i++, m++)
724 btf_dump_emit_type(d, m->type, new_cont_id);
725 } else if (!tstate->fwd_emitted && id != cont_id) {
726 btf_dump_emit_struct_fwd(d, id, t);
727 btf_dump_printf(d, ";\n\n");
728 tstate->fwd_emitted = 1;
729 }
730
731 if (top_level_def) {
732 btf_dump_emit_struct_def(d, id, t, 0);
733 btf_dump_printf(d, ";\n\n");
734 tstate->emit_state = EMITTED;
735 } else {
736 tstate->emit_state = NOT_EMITTED;
737 }
738 break;
739 case BTF_KIND_FUNC_PROTO: {
740 const struct btf_param *p = btf_params(t);
741 __u16 vlen = btf_vlen(t);
742 int i;
743
744 btf_dump_emit_type(d, t->type, cont_id);
745 for (i = 0; i < vlen; i++, p++)
746 btf_dump_emit_type(d, p->type, cont_id);
747
748 break;
749 }
750 default:
751 break;
752 }
753 }
754
755 static int btf_align_of(const struct btf *btf, __u32 id)
756 {
757 const struct btf_type *t = btf__type_by_id(btf, id);
758 __u16 kind = btf_kind(t);
759
760 switch (kind) {
761 case BTF_KIND_INT:
762 case BTF_KIND_ENUM:
763 return min(sizeof(void *), t->size);
764 case BTF_KIND_PTR:
765 return sizeof(void *);
766 case BTF_KIND_TYPEDEF:
767 case BTF_KIND_VOLATILE:
768 case BTF_KIND_CONST:
769 case BTF_KIND_RESTRICT:
770 return btf_align_of(btf, t->type);
771 case BTF_KIND_ARRAY:
772 return btf_align_of(btf, btf_array(t)->type);
773 case BTF_KIND_STRUCT:
774 case BTF_KIND_UNION: {
775 const struct btf_member *m = btf_members(t);
776 __u16 vlen = btf_vlen(t);
777 int i, align = 1;
778
779 for (i = 0; i < vlen; i++, m++)
780 align = max(align, btf_align_of(btf, m->type));
781
782 return align;
783 }
784 default:
785 pr_warning("unsupported BTF_KIND:%u\n", btf_kind(t));
786 return 1;
787 }
788 }
789
790 static bool btf_is_struct_packed(const struct btf *btf, __u32 id,
791 const struct btf_type *t)
792 {
793 const struct btf_member *m;
794 int align, i, bit_sz;
795 __u16 vlen;
796
797 align = btf_align_of(btf, id);
798
799 if (t->size % align)
800 return true;
801
802 m = btf_members(t);
803 vlen = btf_vlen(t);
804
805 for (i = 0; i < vlen; i++, m++) {
806 align = btf_align_of(btf, m->type);
807 bit_sz = btf_member_bitfield_size(t, i);
808 if (bit_sz == 0 && m->offset % (8 * align) != 0)
809 return true;
810 }
811
812
813
814
815
816 return false;
817 }
818
819 static int chip_away_bits(int total, int at_most)
820 {
821 return total % at_most ? : at_most;
822 }
823
824 static void btf_dump_emit_bit_padding(const struct btf_dump *d,
825 int cur_off, int m_off, int m_bit_sz,
826 int align, int lvl)
827 {
828 int off_diff = m_off - cur_off;
829 int ptr_bits = sizeof(void *) * 8;
830
831 if (off_diff <= 0)
832
833 return;
834 if (m_bit_sz == 0 && off_diff < align * 8)
835
836 return;
837
838 while (off_diff > 0) {
839 const char *pad_type;
840 int pad_bits;
841
842 if (ptr_bits > 32 && off_diff > 32) {
843 pad_type = "long";
844 pad_bits = chip_away_bits(off_diff, ptr_bits);
845 } else if (off_diff > 16) {
846 pad_type = "int";
847 pad_bits = chip_away_bits(off_diff, 32);
848 } else if (off_diff > 8) {
849 pad_type = "short";
850 pad_bits = chip_away_bits(off_diff, 16);
851 } else {
852 pad_type = "char";
853 pad_bits = chip_away_bits(off_diff, 8);
854 }
855 btf_dump_printf(d, "\n%s%s: %d;", pfx(lvl), pad_type, pad_bits);
856 off_diff -= pad_bits;
857 }
858 }
859
860 static void btf_dump_emit_struct_fwd(struct btf_dump *d, __u32 id,
861 const struct btf_type *t)
862 {
863 btf_dump_printf(d, "%s %s",
864 btf_is_struct(t) ? "struct" : "union",
865 btf_dump_type_name(d, id));
866 }
867
868 static void btf_dump_emit_struct_def(struct btf_dump *d,
869 __u32 id,
870 const struct btf_type *t,
871 int lvl)
872 {
873 const struct btf_member *m = btf_members(t);
874 bool is_struct = btf_is_struct(t);
875 int align, i, packed, off = 0;
876 __u16 vlen = btf_vlen(t);
877
878 packed = is_struct ? btf_is_struct_packed(d->btf, id, t) : 0;
879
880 btf_dump_printf(d, "%s%s%s {",
881 is_struct ? "struct" : "union",
882 t->name_off ? " " : "",
883 btf_dump_type_name(d, id));
884
885 for (i = 0; i < vlen; i++, m++) {
886 const char *fname;
887 int m_off, m_sz;
888
889 fname = btf_name_of(d, m->name_off);
890 m_sz = btf_member_bitfield_size(t, i);
891 m_off = btf_member_bit_offset(t, i);
892 align = packed ? 1 : btf_align_of(d->btf, m->type);
893
894 btf_dump_emit_bit_padding(d, off, m_off, m_sz, align, lvl + 1);
895 btf_dump_printf(d, "\n%s", pfx(lvl + 1));
896 btf_dump_emit_type_decl(d, m->type, fname, lvl + 1);
897
898 if (m_sz) {
899 btf_dump_printf(d, ": %d", m_sz);
900 off = m_off + m_sz;
901 } else {
902 m_sz = max(0, btf__resolve_size(d->btf, m->type));
903 off = m_off + m_sz * 8;
904 }
905 btf_dump_printf(d, ";");
906 }
907
908
909 if (is_struct) {
910 align = packed ? 1 : btf_align_of(d->btf, id);
911 btf_dump_emit_bit_padding(d, off, t->size * 8, 0, align,
912 lvl + 1);
913 }
914
915 if (vlen)
916 btf_dump_printf(d, "\n");
917 btf_dump_printf(d, "%s}", pfx(lvl));
918 if (packed)
919 btf_dump_printf(d, " __attribute__((packed))");
920 }
921
922 static void btf_dump_emit_enum_fwd(struct btf_dump *d, __u32 id,
923 const struct btf_type *t)
924 {
925 btf_dump_printf(d, "enum %s", btf_dump_type_name(d, id));
926 }
927
928 static void btf_dump_emit_enum_def(struct btf_dump *d, __u32 id,
929 const struct btf_type *t,
930 int lvl)
931 {
932 const struct btf_enum *v = btf_enum(t);
933 __u16 vlen = btf_vlen(t);
934 const char *name;
935 size_t dup_cnt;
936 int i;
937
938 btf_dump_printf(d, "enum%s%s",
939 t->name_off ? " " : "",
940 btf_dump_type_name(d, id));
941
942 if (vlen) {
943 btf_dump_printf(d, " {");
944 for (i = 0; i < vlen; i++, v++) {
945 name = btf_name_of(d, v->name_off);
946
947 dup_cnt = btf_dump_name_dups(d, d->ident_names, name);
948 if (dup_cnt > 1) {
949 btf_dump_printf(d, "\n%s%s___%zu = %d,",
950 pfx(lvl + 1), name, dup_cnt,
951 (__s32)v->val);
952 } else {
953 btf_dump_printf(d, "\n%s%s = %d,",
954 pfx(lvl + 1), name,
955 (__s32)v->val);
956 }
957 }
958 btf_dump_printf(d, "\n%s}", pfx(lvl));
959 }
960 }
961
962 static void btf_dump_emit_fwd_def(struct btf_dump *d, __u32 id,
963 const struct btf_type *t)
964 {
965 const char *name = btf_dump_type_name(d, id);
966
967 if (btf_kflag(t))
968 btf_dump_printf(d, "union %s", name);
969 else
970 btf_dump_printf(d, "struct %s", name);
971 }
972
973 static void btf_dump_emit_typedef_def(struct btf_dump *d, __u32 id,
974 const struct btf_type *t, int lvl)
975 {
976 const char *name = btf_dump_ident_name(d, id);
977
978 btf_dump_printf(d, "typedef ");
979 btf_dump_emit_type_decl(d, t->type, name, lvl);
980 }
981
982 static int btf_dump_push_decl_stack_id(struct btf_dump *d, __u32 id)
983 {
984 __u32 *new_stack;
985 size_t new_cap;
986
987 if (d->decl_stack_cnt >= d->decl_stack_cap) {
988 new_cap = max(16, d->decl_stack_cap * 3 / 2);
989 new_stack = realloc(d->decl_stack,
990 new_cap * sizeof(new_stack[0]));
991 if (!new_stack)
992 return -ENOMEM;
993 d->decl_stack = new_stack;
994 d->decl_stack_cap = new_cap;
995 }
996
997 d->decl_stack[d->decl_stack_cnt++] = id;
998
999 return 0;
1000 }
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043 static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,
1044 const char *fname, int lvl)
1045 {
1046 struct id_stack decl_stack;
1047 const struct btf_type *t;
1048 int err, stack_start;
1049
1050 stack_start = d->decl_stack_cnt;
1051 for (;;) {
1052 err = btf_dump_push_decl_stack_id(d, id);
1053 if (err < 0) {
1054
1055
1056
1057
1058
1059 pr_warning("not enough memory for decl stack:%d", err);
1060 d->decl_stack_cnt = stack_start;
1061 return;
1062 }
1063
1064
1065 if (id == 0)
1066 break;
1067
1068 t = btf__type_by_id(d->btf, id);
1069 switch (btf_kind(t)) {
1070 case BTF_KIND_PTR:
1071 case BTF_KIND_VOLATILE:
1072 case BTF_KIND_CONST:
1073 case BTF_KIND_RESTRICT:
1074 case BTF_KIND_FUNC_PROTO:
1075 id = t->type;
1076 break;
1077 case BTF_KIND_ARRAY:
1078 id = btf_array(t)->type;
1079 break;
1080 case BTF_KIND_INT:
1081 case BTF_KIND_ENUM:
1082 case BTF_KIND_FWD:
1083 case BTF_KIND_STRUCT:
1084 case BTF_KIND_UNION:
1085 case BTF_KIND_TYPEDEF:
1086 goto done;
1087 default:
1088 pr_warning("unexpected type in decl chain, kind:%u, id:[%u]\n",
1089 btf_kind(t), id);
1090 goto done;
1091 }
1092 }
1093 done:
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104 decl_stack.ids = d->decl_stack + stack_start;
1105 decl_stack.cnt = d->decl_stack_cnt - stack_start;
1106 btf_dump_emit_type_chain(d, &decl_stack, fname, lvl);
1107
1108
1109
1110
1111
1112
1113
1114
1115 d->decl_stack_cnt = stack_start;
1116 }
1117
1118 static void btf_dump_emit_mods(struct btf_dump *d, struct id_stack *decl_stack)
1119 {
1120 const struct btf_type *t;
1121 __u32 id;
1122
1123 while (decl_stack->cnt) {
1124 id = decl_stack->ids[decl_stack->cnt - 1];
1125 t = btf__type_by_id(d->btf, id);
1126
1127 switch (btf_kind(t)) {
1128 case BTF_KIND_VOLATILE:
1129 btf_dump_printf(d, "volatile ");
1130 break;
1131 case BTF_KIND_CONST:
1132 btf_dump_printf(d, "const ");
1133 break;
1134 case BTF_KIND_RESTRICT:
1135 btf_dump_printf(d, "restrict ");
1136 break;
1137 default:
1138 return;
1139 }
1140 decl_stack->cnt--;
1141 }
1142 }
1143
1144 static void btf_dump_emit_name(const struct btf_dump *d,
1145 const char *name, bool last_was_ptr)
1146 {
1147 bool separate = name[0] && !last_was_ptr;
1148
1149 btf_dump_printf(d, "%s%s", separate ? " " : "", name);
1150 }
1151
1152 static void btf_dump_emit_type_chain(struct btf_dump *d,
1153 struct id_stack *decls,
1154 const char *fname, int lvl)
1155 {
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165 bool last_was_ptr = true;
1166 const struct btf_type *t;
1167 const char *name;
1168 __u16 kind;
1169 __u32 id;
1170
1171 while (decls->cnt) {
1172 id = decls->ids[--decls->cnt];
1173 if (id == 0) {
1174
1175 btf_dump_emit_mods(d, decls);
1176 btf_dump_printf(d, "void");
1177 last_was_ptr = false;
1178 continue;
1179 }
1180
1181 t = btf__type_by_id(d->btf, id);
1182 kind = btf_kind(t);
1183
1184 switch (kind) {
1185 case BTF_KIND_INT:
1186 btf_dump_emit_mods(d, decls);
1187 name = btf_name_of(d, t->name_off);
1188 btf_dump_printf(d, "%s", name);
1189 break;
1190 case BTF_KIND_STRUCT:
1191 case BTF_KIND_UNION:
1192 btf_dump_emit_mods(d, decls);
1193
1194 if (t->name_off == 0)
1195 btf_dump_emit_struct_def(d, id, t, lvl);
1196 else
1197 btf_dump_emit_struct_fwd(d, id, t);
1198 break;
1199 case BTF_KIND_ENUM:
1200 btf_dump_emit_mods(d, decls);
1201
1202 if (t->name_off == 0)
1203 btf_dump_emit_enum_def(d, id, t, lvl);
1204 else
1205 btf_dump_emit_enum_fwd(d, id, t);
1206 break;
1207 case BTF_KIND_FWD:
1208 btf_dump_emit_mods(d, decls);
1209 btf_dump_emit_fwd_def(d, id, t);
1210 break;
1211 case BTF_KIND_TYPEDEF:
1212 btf_dump_emit_mods(d, decls);
1213 btf_dump_printf(d, "%s", btf_dump_ident_name(d, id));
1214 break;
1215 case BTF_KIND_PTR:
1216 btf_dump_printf(d, "%s", last_was_ptr ? "*" : " *");
1217 break;
1218 case BTF_KIND_VOLATILE:
1219 btf_dump_printf(d, " volatile");
1220 break;
1221 case BTF_KIND_CONST:
1222 btf_dump_printf(d, " const");
1223 break;
1224 case BTF_KIND_RESTRICT:
1225 btf_dump_printf(d, " restrict");
1226 break;
1227 case BTF_KIND_ARRAY: {
1228 const struct btf_array *a = btf_array(t);
1229 const struct btf_type *next_t;
1230 __u32 next_id;
1231 bool multidim;
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242 while (decls->cnt) {
1243 next_id = decls->ids[decls->cnt - 1];
1244 next_t = btf__type_by_id(d->btf, next_id);
1245 if (btf_is_mod(next_t))
1246 decls->cnt--;
1247 else
1248 break;
1249 }
1250
1251 if (decls->cnt == 0) {
1252 btf_dump_emit_name(d, fname, last_was_ptr);
1253 btf_dump_printf(d, "[%u]", a->nelems);
1254 return;
1255 }
1256
1257 next_id = decls->ids[decls->cnt - 1];
1258 next_t = btf__type_by_id(d->btf, next_id);
1259 multidim = btf_is_array(next_t);
1260
1261 if (fname[0] && !last_was_ptr)
1262 btf_dump_printf(d, " ");
1263
1264 if (!multidim)
1265 btf_dump_printf(d, "(");
1266 btf_dump_emit_type_chain(d, decls, fname, lvl);
1267 if (!multidim)
1268 btf_dump_printf(d, ")");
1269 btf_dump_printf(d, "[%u]", a->nelems);
1270 return;
1271 }
1272 case BTF_KIND_FUNC_PROTO: {
1273 const struct btf_param *p = btf_params(t);
1274 __u16 vlen = btf_vlen(t);
1275 int i;
1276
1277 btf_dump_emit_mods(d, decls);
1278 if (decls->cnt) {
1279 btf_dump_printf(d, " (");
1280 btf_dump_emit_type_chain(d, decls, fname, lvl);
1281 btf_dump_printf(d, ")");
1282 } else {
1283 btf_dump_emit_name(d, fname, last_was_ptr);
1284 }
1285 btf_dump_printf(d, "(");
1286
1287
1288
1289
1290
1291
1292 if (vlen == 1 && p->type == 0) {
1293 btf_dump_printf(d, ")");
1294 return;
1295 }
1296
1297 for (i = 0; i < vlen; i++, p++) {
1298 if (i > 0)
1299 btf_dump_printf(d, ", ");
1300
1301
1302 if (i == vlen - 1 && p->type == 0) {
1303 btf_dump_printf(d, "...");
1304 break;
1305 }
1306
1307 name = btf_name_of(d, p->name_off);
1308 btf_dump_emit_type_decl(d, p->type, name, lvl);
1309 }
1310
1311 btf_dump_printf(d, ")");
1312 return;
1313 }
1314 default:
1315 pr_warning("unexpected type in decl chain, kind:%u, id:[%u]\n",
1316 kind, id);
1317 return;
1318 }
1319
1320 last_was_ptr = kind == BTF_KIND_PTR;
1321 }
1322
1323 btf_dump_emit_name(d, fname, last_was_ptr);
1324 }
1325
1326
1327 static size_t btf_dump_name_dups(struct btf_dump *d, struct hashmap *name_map,
1328 const char *orig_name)
1329 {
1330 size_t dup_cnt = 0;
1331
1332 hashmap__find(name_map, orig_name, (void **)&dup_cnt);
1333 dup_cnt++;
1334 hashmap__set(name_map, orig_name, (void *)dup_cnt, NULL, NULL);
1335
1336 return dup_cnt;
1337 }
1338
1339 static const char *btf_dump_resolve_name(struct btf_dump *d, __u32 id,
1340 struct hashmap *name_map)
1341 {
1342 struct btf_dump_type_aux_state *s = &d->type_states[id];
1343 const struct btf_type *t = btf__type_by_id(d->btf, id);
1344 const char *orig_name = btf_name_of(d, t->name_off);
1345 const char **cached_name = &d->cached_names[id];
1346 size_t dup_cnt;
1347
1348 if (t->name_off == 0)
1349 return "";
1350
1351 if (s->name_resolved)
1352 return *cached_name ? *cached_name : orig_name;
1353
1354 dup_cnt = btf_dump_name_dups(d, name_map, orig_name);
1355 if (dup_cnt > 1) {
1356 const size_t max_len = 256;
1357 char new_name[max_len];
1358
1359 snprintf(new_name, max_len, "%s___%zu", orig_name, dup_cnt);
1360 *cached_name = strdup(new_name);
1361 }
1362
1363 s->name_resolved = 1;
1364 return *cached_name ? *cached_name : orig_name;
1365 }
1366
1367 static const char *btf_dump_type_name(struct btf_dump *d, __u32 id)
1368 {
1369 return btf_dump_resolve_name(d, id, d->type_names);
1370 }
1371
1372 static const char *btf_dump_ident_name(struct btf_dump *d, __u32 id)
1373 {
1374 return btf_dump_resolve_name(d, id, d->ident_names);
1375 }