Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2/* Copyright (C) 2019 Facebook */
3
4#ifndef _GNU_SOURCE
5#define _GNU_SOURCE
6#endif
7#include <ctype.h>
8#include <errno.h>
9#include <fcntl.h>
10#include <libgen.h>
11#include <linux/err.h>
12#include <stdbool.h>
13#include <stdio.h>
14#include <string.h>
15#include <unistd.h>
16#include <bpf/bpf.h>
17#include <bpf/libbpf.h>
18#include <bpf/libbpf_internal.h>
19#include <sys/types.h>
20#include <sys/stat.h>
21#include <sys/mman.h>
22#include <bpf/btf.h>
23
24#include "json_writer.h"
25#include "main.h"
26
27#define MAX_OBJ_NAME_LEN 64
28
29static void sanitize_identifier(char *name)
30{
31 int i;
32
33 for (i = 0; name[i]; i++)
34 if (!isalnum(name[i]) && name[i] != '_')
35 name[i] = '_';
36}
37
38static bool str_has_prefix(const char *str, const char *prefix)
39{
40 return strncmp(str, prefix, strlen(prefix)) == 0;
41}
42
43static bool str_has_suffix(const char *str, const char *suffix)
44{
45 size_t i, n1 = strlen(str), n2 = strlen(suffix);
46
47 if (n1 < n2)
48 return false;
49
50 for (i = 0; i < n2; i++) {
51 if (str[n1 - i - 1] != suffix[n2 - i - 1])
52 return false;
53 }
54
55 return true;
56}
57
58static const struct btf_type *
59resolve_func_ptr(const struct btf *btf, __u32 id, __u32 *res_id)
60{
61 const struct btf_type *t;
62
63 t = skip_mods_and_typedefs(btf, id, NULL);
64 if (!btf_is_ptr(t))
65 return NULL;
66
67 t = skip_mods_and_typedefs(btf, t->type, res_id);
68
69 return btf_is_func_proto(t) ? t : NULL;
70}
71
72static void get_obj_name(char *name, const char *file)
73{
74 char file_copy[PATH_MAX];
75
76 /* Using basename() POSIX version to be more portable. */
77 strncpy(file_copy, file, PATH_MAX - 1)[PATH_MAX - 1] = '\0';
78 strncpy(name, basename(file_copy), MAX_OBJ_NAME_LEN - 1)[MAX_OBJ_NAME_LEN - 1] = '\0';
79 if (str_has_suffix(name, ".o"))
80 name[strlen(name) - 2] = '\0';
81 sanitize_identifier(name);
82}
83
84static void get_header_guard(char *guard, const char *obj_name, const char *suffix)
85{
86 int i;
87
88 sprintf(guard, "__%s_%s__", obj_name, suffix);
89 for (i = 0; guard[i]; i++)
90 guard[i] = toupper(guard[i]);
91}
92
93static bool get_map_ident(const struct bpf_map *map, char *buf, size_t buf_sz)
94{
95 static const char *sfxs[] = { ".data", ".rodata", ".bss", ".kconfig" };
96 const char *name = bpf_map__name(map);
97 int i, n;
98
99 if (!bpf_map__is_internal(map)) {
100 snprintf(buf, buf_sz, "%s", name);
101 return true;
102 }
103
104 for (i = 0, n = ARRAY_SIZE(sfxs); i < n; i++) {
105 const char *sfx = sfxs[i], *p;
106
107 p = strstr(name, sfx);
108 if (p) {
109 snprintf(buf, buf_sz, "%s", p + 1);
110 sanitize_identifier(buf);
111 return true;
112 }
113 }
114
115 return false;
116}
117
118static bool get_datasec_ident(const char *sec_name, char *buf, size_t buf_sz)
119{
120 static const char *pfxs[] = { ".data", ".rodata", ".bss", ".kconfig" };
121 int i, n;
122
123 /* recognize hard coded LLVM section name */
124 if (strcmp(sec_name, ".addr_space.1") == 0) {
125 /* this is the name to use in skeleton */
126 snprintf(buf, buf_sz, "arena");
127 return true;
128 }
129 for (i = 0, n = ARRAY_SIZE(pfxs); i < n; i++) {
130 const char *pfx = pfxs[i];
131
132 if (str_has_prefix(sec_name, pfx)) {
133 snprintf(buf, buf_sz, "%s", sec_name + 1);
134 sanitize_identifier(buf);
135 return true;
136 }
137 }
138
139 return false;
140}
141
142static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args)
143{
144 vprintf(fmt, args);
145}
146
147static int codegen_datasec_def(struct bpf_object *obj,
148 struct btf *btf,
149 struct btf_dump *d,
150 const struct btf_type *sec,
151 const char *obj_name)
152{
153 const char *sec_name = btf__name_by_offset(btf, sec->name_off);
154 const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec);
155 int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec);
156 char var_ident[256], sec_ident[256];
157 bool strip_mods = false;
158
159 if (!get_datasec_ident(sec_name, sec_ident, sizeof(sec_ident)))
160 return 0;
161
162 if (strcmp(sec_name, ".kconfig") != 0)
163 strip_mods = true;
164
165 printf(" struct %s__%s {\n", obj_name, sec_ident);
166 for (i = 0; i < vlen; i++, sec_var++) {
167 const struct btf_type *var = btf__type_by_id(btf, sec_var->type);
168 const char *var_name = btf__name_by_offset(btf, var->name_off);
169 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts,
170 .field_name = var_ident,
171 .indent_level = 2,
172 .strip_mods = strip_mods,
173 );
174 int need_off = sec_var->offset, align_off, align;
175 __u32 var_type_id = var->type;
176
177 /* static variables are not exposed through BPF skeleton */
178 if (btf_var(var)->linkage == BTF_VAR_STATIC)
179 continue;
180
181 if (off > need_off) {
182 p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n",
183 sec_name, i, need_off, off);
184 return -EINVAL;
185 }
186
187 align = btf__align_of(btf, var->type);
188 if (align <= 0) {
189 p_err("Failed to determine alignment of variable '%s': %d",
190 var_name, align);
191 return -EINVAL;
192 }
193 /* Assume 32-bit architectures when generating data section
194 * struct memory layout. Given bpftool can't know which target
195 * host architecture it's emitting skeleton for, we need to be
196 * conservative and assume 32-bit one to ensure enough padding
197 * bytes are generated for pointer and long types. This will
198 * still work correctly for 64-bit architectures, because in
199 * the worst case we'll generate unnecessary padding field,
200 * which on 64-bit architectures is not strictly necessary and
201 * would be handled by natural 8-byte alignment. But it still
202 * will be a correct memory layout, based on recorded offsets
203 * in BTF.
204 */
205 if (align > 4)
206 align = 4;
207
208 align_off = (off + align - 1) / align * align;
209 if (align_off != need_off) {
210 printf("\t\tchar __pad%d[%d];\n",
211 pad_cnt, need_off - off);
212 pad_cnt++;
213 }
214
215 /* sanitize variable name, e.g., for static vars inside
216 * a function, it's name is '<function name>.<variable name>',
217 * which we'll turn into a '<function name>_<variable name>'
218 */
219 var_ident[0] = '\0';
220 strncat(var_ident, var_name, sizeof(var_ident) - 1);
221 sanitize_identifier(var_ident);
222
223 printf("\t\t");
224 err = btf_dump__emit_type_decl(d, var_type_id, &opts);
225 if (err)
226 return err;
227 printf(";\n");
228
229 off = sec_var->offset + sec_var->size;
230 }
231 printf(" } *%s;\n", sec_ident);
232 return 0;
233}
234
235static const struct btf_type *find_type_for_map(struct btf *btf, const char *map_ident)
236{
237 int n = btf__type_cnt(btf), i;
238 char sec_ident[256];
239
240 for (i = 1; i < n; i++) {
241 const struct btf_type *t = btf__type_by_id(btf, i);
242 const char *name;
243
244 if (!btf_is_datasec(t))
245 continue;
246
247 name = btf__str_by_offset(btf, t->name_off);
248 if (!get_datasec_ident(name, sec_ident, sizeof(sec_ident)))
249 continue;
250
251 if (strcmp(sec_ident, map_ident) == 0)
252 return t;
253 }
254 return NULL;
255}
256
257static bool is_mmapable_map(const struct bpf_map *map, char *buf, size_t sz)
258{
259 size_t tmp_sz;
260
261 if (bpf_map__type(map) == BPF_MAP_TYPE_ARENA && bpf_map__initial_value(map, &tmp_sz)) {
262 snprintf(buf, sz, "arena");
263 return true;
264 }
265
266 if (!bpf_map__is_internal(map) || !(bpf_map__map_flags(map) & BPF_F_MMAPABLE))
267 return false;
268
269 if (!get_map_ident(map, buf, sz))
270 return false;
271
272 return true;
273}
274
275static int codegen_datasecs(struct bpf_object *obj, const char *obj_name)
276{
277 struct btf *btf = bpf_object__btf(obj);
278 struct btf_dump *d;
279 struct bpf_map *map;
280 const struct btf_type *sec;
281 char map_ident[256];
282 int err = 0;
283
284 d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);
285 if (!d)
286 return -errno;
287
288 bpf_object__for_each_map(map, obj) {
289 /* only generate definitions for memory-mapped internal maps */
290 if (!is_mmapable_map(map, map_ident, sizeof(map_ident)))
291 continue;
292
293 sec = find_type_for_map(btf, map_ident);
294
295 /* In some cases (e.g., sections like .rodata.cst16 containing
296 * compiler allocated string constants only) there will be
297 * special internal maps with no corresponding DATASEC BTF
298 * type. In such case, generate empty structs for each such
299 * map. It will still be memory-mapped and its contents
300 * accessible from user-space through BPF skeleton.
301 */
302 if (!sec) {
303 printf(" struct %s__%s {\n", obj_name, map_ident);
304 printf(" } *%s;\n", map_ident);
305 } else {
306 err = codegen_datasec_def(obj, btf, d, sec, obj_name);
307 if (err)
308 goto out;
309 }
310 }
311
312
313out:
314 btf_dump__free(d);
315 return err;
316}
317
318static bool btf_is_ptr_to_func_proto(const struct btf *btf,
319 const struct btf_type *v)
320{
321 return btf_is_ptr(v) && btf_is_func_proto(btf__type_by_id(btf, v->type));
322}
323
324static int codegen_subskel_datasecs(struct bpf_object *obj, const char *obj_name)
325{
326 struct btf *btf = bpf_object__btf(obj);
327 struct btf_dump *d;
328 struct bpf_map *map;
329 const struct btf_type *sec, *var;
330 const struct btf_var_secinfo *sec_var;
331 int i, err = 0, vlen;
332 char map_ident[256], sec_ident[256];
333 bool strip_mods = false, needs_typeof = false;
334 const char *sec_name, *var_name;
335 __u32 var_type_id;
336
337 d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);
338 if (!d)
339 return -errno;
340
341 bpf_object__for_each_map(map, obj) {
342 /* only generate definitions for memory-mapped internal maps */
343 if (!is_mmapable_map(map, map_ident, sizeof(map_ident)))
344 continue;
345
346 sec = find_type_for_map(btf, map_ident);
347 if (!sec)
348 continue;
349
350 sec_name = btf__name_by_offset(btf, sec->name_off);
351 if (!get_datasec_ident(sec_name, sec_ident, sizeof(sec_ident)))
352 continue;
353
354 strip_mods = strcmp(sec_name, ".kconfig") != 0;
355 printf(" struct %s__%s {\n", obj_name, sec_ident);
356
357 sec_var = btf_var_secinfos(sec);
358 vlen = btf_vlen(sec);
359 for (i = 0; i < vlen; i++, sec_var++) {
360 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts,
361 .indent_level = 2,
362 .strip_mods = strip_mods,
363 /* we'll print the name separately */
364 .field_name = "",
365 );
366
367 var = btf__type_by_id(btf, sec_var->type);
368 var_name = btf__name_by_offset(btf, var->name_off);
369 var_type_id = var->type;
370
371 /* static variables are not exposed through BPF skeleton */
372 if (btf_var(var)->linkage == BTF_VAR_STATIC)
373 continue;
374
375 /* The datasec member has KIND_VAR but we want the
376 * underlying type of the variable (e.g. KIND_INT).
377 */
378 var = skip_mods_and_typedefs(btf, var->type, NULL);
379
380 printf("\t\t");
381 /* Func and array members require special handling.
382 * Instead of producing `typename *var`, they produce
383 * `typeof(typename) *var`. This allows us to keep a
384 * similar syntax where the identifier is just prefixed
385 * by *, allowing us to ignore C declaration minutiae.
386 */
387 needs_typeof = btf_is_array(var) || btf_is_ptr_to_func_proto(btf, var);
388 if (needs_typeof)
389 printf("__typeof__(");
390
391 err = btf_dump__emit_type_decl(d, var_type_id, &opts);
392 if (err)
393 goto out;
394
395 if (needs_typeof)
396 printf(")");
397
398 printf(" *%s;\n", var_name);
399 }
400 printf(" } %s;\n", sec_ident);
401 }
402
403out:
404 btf_dump__free(d);
405 return err;
406}
407
408static void codegen(const char *template, ...)
409{
410 const char *src, *end;
411 int skip_tabs = 0, n;
412 char *s, *dst;
413 va_list args;
414 char c;
415
416 n = strlen(template);
417 s = malloc(n + 1);
418 if (!s)
419 exit(-1);
420 src = template;
421 dst = s;
422
423 /* find out "baseline" indentation to skip */
424 while ((c = *src++)) {
425 if (c == '\t') {
426 skip_tabs++;
427 } else if (c == '\n') {
428 break;
429 } else {
430 p_err("unrecognized character at pos %td in template '%s': '%c'",
431 src - template - 1, template, c);
432 free(s);
433 exit(-1);
434 }
435 }
436
437 while (*src) {
438 /* skip baseline indentation tabs */
439 for (n = skip_tabs; n > 0; n--, src++) {
440 if (*src != '\t') {
441 p_err("not enough tabs at pos %td in template '%s'",
442 src - template - 1, template);
443 free(s);
444 exit(-1);
445 }
446 }
447 /* trim trailing whitespace */
448 end = strchrnul(src, '\n');
449 for (n = end - src; n > 0 && isspace(src[n - 1]); n--)
450 ;
451 memcpy(dst, src, n);
452 dst += n;
453 if (*end)
454 *dst++ = '\n';
455 src = *end ? end + 1 : end;
456 }
457 *dst++ = '\0';
458
459 /* print out using adjusted template */
460 va_start(args, template);
461 n = vprintf(s, args);
462 va_end(args);
463
464 free(s);
465}
466
467static void print_hex(const char *data, int data_sz)
468{
469 int i, len;
470
471 for (i = 0, len = 0; i < data_sz; i++) {
472 int w = data[i] ? 4 : 2;
473
474 len += w;
475 if (len > 78) {
476 printf("\\\n");
477 len = w;
478 }
479 if (!data[i])
480 printf("\\0");
481 else
482 printf("\\x%02x", (unsigned char)data[i]);
483 }
484}
485
486static size_t bpf_map_mmap_sz(const struct bpf_map *map)
487{
488 long page_sz = sysconf(_SC_PAGE_SIZE);
489 size_t map_sz;
490
491 map_sz = (size_t)roundup(bpf_map__value_size(map), 8) * bpf_map__max_entries(map);
492 map_sz = roundup(map_sz, page_sz);
493 return map_sz;
494}
495
496/* Emit type size asserts for all top-level fields in memory-mapped internal maps. */
497static void codegen_asserts(struct bpf_object *obj, const char *obj_name)
498{
499 struct btf *btf = bpf_object__btf(obj);
500 struct bpf_map *map;
501 struct btf_var_secinfo *sec_var;
502 int i, vlen;
503 const struct btf_type *sec;
504 char map_ident[256], var_ident[256];
505
506 if (!btf)
507 return;
508
509 codegen("\
510 \n\
511 __attribute__((unused)) static void \n\
512 %1$s__assert(struct %1$s *s __attribute__((unused))) \n\
513 { \n\
514 #ifdef __cplusplus \n\
515 #define _Static_assert static_assert \n\
516 #endif \n\
517 ", obj_name);
518
519 bpf_object__for_each_map(map, obj) {
520 if (!is_mmapable_map(map, map_ident, sizeof(map_ident)))
521 continue;
522
523 sec = find_type_for_map(btf, map_ident);
524 if (!sec) {
525 /* best effort, couldn't find the type for this map */
526 continue;
527 }
528
529 sec_var = btf_var_secinfos(sec);
530 vlen = btf_vlen(sec);
531
532 for (i = 0; i < vlen; i++, sec_var++) {
533 const struct btf_type *var = btf__type_by_id(btf, sec_var->type);
534 const char *var_name = btf__name_by_offset(btf, var->name_off);
535 long var_size;
536
537 /* static variables are not exposed through BPF skeleton */
538 if (btf_var(var)->linkage == BTF_VAR_STATIC)
539 continue;
540
541 var_size = btf__resolve_size(btf, var->type);
542 if (var_size < 0)
543 continue;
544
545 var_ident[0] = '\0';
546 strncat(var_ident, var_name, sizeof(var_ident) - 1);
547 sanitize_identifier(var_ident);
548
549 printf("\t_Static_assert(sizeof(s->%s->%s) == %ld, \"unexpected size of '%s'\");\n",
550 map_ident, var_ident, var_size, var_ident);
551 }
552 }
553 codegen("\
554 \n\
555 #ifdef __cplusplus \n\
556 #undef _Static_assert \n\
557 #endif \n\
558 } \n\
559 ");
560}
561
562static void codegen_attach_detach(struct bpf_object *obj, const char *obj_name)
563{
564 struct bpf_program *prog;
565
566 bpf_object__for_each_program(prog, obj) {
567 const char *tp_name;
568
569 codegen("\
570 \n\
571 \n\
572 static inline int \n\
573 %1$s__%2$s__attach(struct %1$s *skel) \n\
574 { \n\
575 int prog_fd = skel->progs.%2$s.prog_fd; \n\
576 ", obj_name, bpf_program__name(prog));
577
578 switch (bpf_program__type(prog)) {
579 case BPF_PROG_TYPE_RAW_TRACEPOINT:
580 tp_name = strchr(bpf_program__section_name(prog), '/') + 1;
581 printf("\tint fd = skel_raw_tracepoint_open(\"%s\", prog_fd);\n", tp_name);
582 break;
583 case BPF_PROG_TYPE_TRACING:
584 case BPF_PROG_TYPE_LSM:
585 if (bpf_program__expected_attach_type(prog) == BPF_TRACE_ITER)
586 printf("\tint fd = skel_link_create(prog_fd, 0, BPF_TRACE_ITER);\n");
587 else
588 printf("\tint fd = skel_raw_tracepoint_open(NULL, prog_fd);\n");
589 break;
590 default:
591 printf("\tint fd = ((void)prog_fd, 0); /* auto-attach not supported */\n");
592 break;
593 }
594 codegen("\
595 \n\
596 \n\
597 if (fd > 0) \n\
598 skel->links.%1$s_fd = fd; \n\
599 return fd; \n\
600 } \n\
601 ", bpf_program__name(prog));
602 }
603
604 codegen("\
605 \n\
606 \n\
607 static inline int \n\
608 %1$s__attach(struct %1$s *skel) \n\
609 { \n\
610 int ret = 0; \n\
611 \n\
612 ", obj_name);
613
614 bpf_object__for_each_program(prog, obj) {
615 codegen("\
616 \n\
617 ret = ret < 0 ? ret : %1$s__%2$s__attach(skel); \n\
618 ", obj_name, bpf_program__name(prog));
619 }
620
621 codegen("\
622 \n\
623 return ret < 0 ? ret : 0; \n\
624 } \n\
625 \n\
626 static inline void \n\
627 %1$s__detach(struct %1$s *skel) \n\
628 { \n\
629 ", obj_name);
630
631 bpf_object__for_each_program(prog, obj) {
632 codegen("\
633 \n\
634 skel_closenz(skel->links.%1$s_fd); \n\
635 ", bpf_program__name(prog));
636 }
637
638 codegen("\
639 \n\
640 } \n\
641 ");
642}
643
644static void codegen_destroy(struct bpf_object *obj, const char *obj_name)
645{
646 struct bpf_program *prog;
647 struct bpf_map *map;
648 char ident[256];
649
650 codegen("\
651 \n\
652 static void \n\
653 %1$s__destroy(struct %1$s *skel) \n\
654 { \n\
655 if (!skel) \n\
656 return; \n\
657 %1$s__detach(skel); \n\
658 ",
659 obj_name);
660
661 bpf_object__for_each_program(prog, obj) {
662 codegen("\
663 \n\
664 skel_closenz(skel->progs.%1$s.prog_fd); \n\
665 ", bpf_program__name(prog));
666 }
667
668 bpf_object__for_each_map(map, obj) {
669 if (!get_map_ident(map, ident, sizeof(ident)))
670 continue;
671 if (bpf_map__is_internal(map) &&
672 (bpf_map__map_flags(map) & BPF_F_MMAPABLE))
673 printf("\tskel_free_map_data(skel->%1$s, skel->maps.%1$s.initial_value, %2$zd);\n",
674 ident, bpf_map_mmap_sz(map));
675 codegen("\
676 \n\
677 skel_closenz(skel->maps.%1$s.map_fd); \n\
678 ", ident);
679 }
680 codegen("\
681 \n\
682 skel_free(skel); \n\
683 } \n\
684 ",
685 obj_name);
686}
687
688static int gen_trace(struct bpf_object *obj, const char *obj_name, const char *header_guard)
689{
690 DECLARE_LIBBPF_OPTS(gen_loader_opts, opts);
691 struct bpf_map *map;
692 char ident[256];
693 int err = 0;
694
695 err = bpf_object__gen_loader(obj, &opts);
696 if (err)
697 return err;
698
699 err = bpf_object__load(obj);
700 if (err) {
701 p_err("failed to load object file");
702 goto out;
703 }
704 /* If there was no error during load then gen_loader_opts
705 * are populated with the loader program.
706 */
707
708 /* finish generating 'struct skel' */
709 codegen("\
710 \n\
711 }; \n\
712 ", obj_name);
713
714
715 codegen_attach_detach(obj, obj_name);
716
717 codegen_destroy(obj, obj_name);
718
719 codegen("\
720 \n\
721 static inline struct %1$s * \n\
722 %1$s__open(void) \n\
723 { \n\
724 struct %1$s *skel; \n\
725 \n\
726 skel = skel_alloc(sizeof(*skel)); \n\
727 if (!skel) \n\
728 goto cleanup; \n\
729 skel->ctx.sz = (void *)&skel->links - (void *)skel; \n\
730 ",
731 obj_name, opts.data_sz);
732 bpf_object__for_each_map(map, obj) {
733 const void *mmap_data = NULL;
734 size_t mmap_size = 0;
735
736 if (!is_mmapable_map(map, ident, sizeof(ident)))
737 continue;
738
739 codegen("\
740 \n\
741 { \n\
742 static const char data[] __attribute__((__aligned__(8))) = \"\\\n\
743 ");
744 mmap_data = bpf_map__initial_value(map, &mmap_size);
745 print_hex(mmap_data, mmap_size);
746 codegen("\
747 \n\
748 \"; \n\
749 \n\
750 skel->%1$s = skel_prep_map_data((void *)data, %2$zd,\n\
751 sizeof(data) - 1);\n\
752 if (!skel->%1$s) \n\
753 goto cleanup; \n\
754 skel->maps.%1$s.initial_value = (__u64) (long) skel->%1$s;\n\
755 } \n\
756 ", ident, bpf_map_mmap_sz(map));
757 }
758 codegen("\
759 \n\
760 return skel; \n\
761 cleanup: \n\
762 %1$s__destroy(skel); \n\
763 return NULL; \n\
764 } \n\
765 \n\
766 static inline int \n\
767 %1$s__load(struct %1$s *skel) \n\
768 { \n\
769 struct bpf_load_and_run_opts opts = {}; \n\
770 int err; \n\
771 static const char opts_data[] __attribute__((__aligned__(8))) = \"\\\n\
772 ",
773 obj_name);
774 print_hex(opts.data, opts.data_sz);
775 codegen("\
776 \n\
777 \"; \n\
778 static const char opts_insn[] __attribute__((__aligned__(8))) = \"\\\n\
779 ");
780 print_hex(opts.insns, opts.insns_sz);
781 codegen("\
782 \n\
783 \"; \n\
784 \n\
785 opts.ctx = (struct bpf_loader_ctx *)skel; \n\
786 opts.data_sz = sizeof(opts_data) - 1; \n\
787 opts.data = (void *)opts_data; \n\
788 opts.insns_sz = sizeof(opts_insn) - 1; \n\
789 opts.insns = (void *)opts_insn; \n\
790 \n\
791 err = bpf_load_and_run(&opts); \n\
792 if (err < 0) \n\
793 return err; \n\
794 ");
795 bpf_object__for_each_map(map, obj) {
796 const char *mmap_flags;
797
798 if (!is_mmapable_map(map, ident, sizeof(ident)))
799 continue;
800
801 if (bpf_map__map_flags(map) & BPF_F_RDONLY_PROG)
802 mmap_flags = "PROT_READ";
803 else
804 mmap_flags = "PROT_READ | PROT_WRITE";
805
806 codegen("\
807 \n\
808 skel->%1$s = skel_finalize_map_data(&skel->maps.%1$s.initial_value, \n\
809 %2$zd, %3$s, skel->maps.%1$s.map_fd);\n\
810 if (!skel->%1$s) \n\
811 return -ENOMEM; \n\
812 ",
813 ident, bpf_map_mmap_sz(map), mmap_flags);
814 }
815 codegen("\
816 \n\
817 return 0; \n\
818 } \n\
819 \n\
820 static inline struct %1$s * \n\
821 %1$s__open_and_load(void) \n\
822 { \n\
823 struct %1$s *skel; \n\
824 \n\
825 skel = %1$s__open(); \n\
826 if (!skel) \n\
827 return NULL; \n\
828 if (%1$s__load(skel)) { \n\
829 %1$s__destroy(skel); \n\
830 return NULL; \n\
831 } \n\
832 return skel; \n\
833 } \n\
834 \n\
835 ", obj_name);
836
837 codegen_asserts(obj, obj_name);
838
839 codegen("\
840 \n\
841 \n\
842 #endif /* %s */ \n\
843 ",
844 header_guard);
845 err = 0;
846out:
847 return err;
848}
849
850static void
851codegen_maps_skeleton(struct bpf_object *obj, size_t map_cnt, bool mmaped, bool populate_links)
852{
853 struct bpf_map *map;
854 char ident[256];
855 size_t i, map_sz;
856
857 if (!map_cnt)
858 return;
859
860 /* for backward compatibility with old libbpf versions that don't
861 * handle new BPF skeleton with new struct bpf_map_skeleton definition
862 * that includes link field, avoid specifying new increased size,
863 * unless we absolutely have to (i.e., if there are struct_ops maps
864 * present)
865 */
866 map_sz = offsetof(struct bpf_map_skeleton, link);
867 if (populate_links) {
868 bpf_object__for_each_map(map, obj) {
869 if (bpf_map__type(map) == BPF_MAP_TYPE_STRUCT_OPS) {
870 map_sz = sizeof(struct bpf_map_skeleton);
871 break;
872 }
873 }
874 }
875
876 codegen("\
877 \n\
878 \n\
879 /* maps */ \n\
880 s->map_cnt = %zu; \n\
881 s->map_skel_sz = %zu; \n\
882 s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt,\n\
883 sizeof(*s->maps) > %zu ? sizeof(*s->maps) : %zu);\n\
884 if (!s->maps) { \n\
885 err = -ENOMEM; \n\
886 goto err; \n\
887 } \n\
888 ",
889 map_cnt, map_sz, map_sz, map_sz
890 );
891 i = 0;
892 bpf_object__for_each_map(map, obj) {
893 if (!get_map_ident(map, ident, sizeof(ident)))
894 continue;
895
896 codegen("\
897 \n\
898 \n\
899 map = (struct bpf_map_skeleton *)((char *)s->maps + %zu * s->map_skel_sz);\n\
900 map->name = \"%s\"; \n\
901 map->map = &obj->maps.%s; \n\
902 ",
903 i, bpf_map__name(map), ident);
904 /* memory-mapped internal maps */
905 if (mmaped && is_mmapable_map(map, ident, sizeof(ident))) {
906 printf("\tmap->mmaped = (void **)&obj->%s;\n", ident);
907 }
908
909 if (populate_links && bpf_map__type(map) == BPF_MAP_TYPE_STRUCT_OPS) {
910 codegen("\
911 \n\
912 map->link = &obj->links.%s; \n\
913 ", ident);
914 }
915 i++;
916 }
917}
918
919static void
920codegen_progs_skeleton(struct bpf_object *obj, size_t prog_cnt, bool populate_links)
921{
922 struct bpf_program *prog;
923 int i;
924
925 if (!prog_cnt)
926 return;
927
928 codegen("\
929 \n\
930 \n\
931 /* programs */ \n\
932 s->prog_cnt = %zu; \n\
933 s->prog_skel_sz = sizeof(*s->progs); \n\
934 s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\
935 if (!s->progs) { \n\
936 err = -ENOMEM; \n\
937 goto err; \n\
938 } \n\
939 ",
940 prog_cnt
941 );
942 i = 0;
943 bpf_object__for_each_program(prog, obj) {
944 codegen("\
945 \n\
946 \n\
947 s->progs[%1$zu].name = \"%2$s\"; \n\
948 s->progs[%1$zu].prog = &obj->progs.%2$s;\n\
949 ",
950 i, bpf_program__name(prog));
951
952 if (populate_links) {
953 codegen("\
954 \n\
955 s->progs[%1$zu].link = &obj->links.%2$s;\n\
956 ",
957 i, bpf_program__name(prog));
958 }
959 i++;
960 }
961}
962
963static int walk_st_ops_shadow_vars(struct btf *btf, const char *ident,
964 const struct btf_type *map_type, __u32 map_type_id)
965{
966 LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts, .indent_level = 3);
967 const struct btf_type *member_type;
968 __u32 offset, next_offset = 0;
969 const struct btf_member *m;
970 struct btf_dump *d = NULL;
971 const char *member_name;
972 __u32 member_type_id;
973 int i, err = 0, n;
974 int size;
975
976 d = btf_dump__new(btf, codegen_btf_dump_printf, NULL, NULL);
977 if (!d)
978 return -errno;
979
980 n = btf_vlen(map_type);
981 for (i = 0, m = btf_members(map_type); i < n; i++, m++) {
982 member_type = skip_mods_and_typedefs(btf, m->type, &member_type_id);
983 member_name = btf__name_by_offset(btf, m->name_off);
984
985 offset = m->offset / 8;
986 if (next_offset < offset)
987 printf("\t\t\tchar __padding_%d[%d];\n", i, offset - next_offset);
988
989 switch (btf_kind(member_type)) {
990 case BTF_KIND_INT:
991 case BTF_KIND_FLOAT:
992 case BTF_KIND_ENUM:
993 case BTF_KIND_ENUM64:
994 /* scalar type */
995 printf("\t\t\t");
996 opts.field_name = member_name;
997 err = btf_dump__emit_type_decl(d, member_type_id, &opts);
998 if (err) {
999 p_err("Failed to emit type declaration for %s: %d", member_name, err);
1000 goto out;
1001 }
1002 printf(";\n");
1003
1004 size = btf__resolve_size(btf, member_type_id);
1005 if (size < 0) {
1006 p_err("Failed to resolve size of %s: %d\n", member_name, size);
1007 err = size;
1008 goto out;
1009 }
1010
1011 next_offset = offset + size;
1012 break;
1013
1014 case BTF_KIND_PTR:
1015 if (resolve_func_ptr(btf, m->type, NULL)) {
1016 /* Function pointer */
1017 printf("\t\t\tstruct bpf_program *%s;\n", member_name);
1018
1019 next_offset = offset + sizeof(void *);
1020 break;
1021 }
1022 /* All pointer types are unsupported except for
1023 * function pointers.
1024 */
1025 fallthrough;
1026
1027 default:
1028 /* Unsupported types
1029 *
1030 * Types other than scalar types and function
1031 * pointers are currently not supported in order to
1032 * prevent conflicts in the generated code caused
1033 * by multiple definitions. For instance, if the
1034 * struct type FOO is used in a struct_ops map,
1035 * bpftool has to generate definitions for FOO,
1036 * which may result in conflicts if FOO is defined
1037 * in different skeleton files.
1038 */
1039 size = btf__resolve_size(btf, member_type_id);
1040 if (size < 0) {
1041 p_err("Failed to resolve size of %s: %d\n", member_name, size);
1042 err = size;
1043 goto out;
1044 }
1045 printf("\t\t\tchar __unsupported_%d[%d];\n", i, size);
1046
1047 next_offset = offset + size;
1048 break;
1049 }
1050 }
1051
1052 /* Cannot fail since it must be a struct type */
1053 size = btf__resolve_size(btf, map_type_id);
1054 if (next_offset < (__u32)size)
1055 printf("\t\t\tchar __padding_end[%d];\n", size - next_offset);
1056
1057out:
1058 btf_dump__free(d);
1059
1060 return err;
1061}
1062
1063/* Generate the pointer of the shadow type for a struct_ops map.
1064 *
1065 * This function adds a pointer of the shadow type for a struct_ops map.
1066 * The members of a struct_ops map can be exported through a pointer to a
1067 * shadow type. The user can access these members through the pointer.
1068 *
1069 * A shadow type includes not all members, only members of some types.
1070 * They are scalar types and function pointers. The function pointers are
1071 * translated to the pointer of the struct bpf_program. The scalar types
1072 * are translated to the original type without any modifiers.
1073 *
1074 * Unsupported types will be translated to a char array to occupy the same
1075 * space as the original field, being renamed as __unsupported_*. The user
1076 * should treat these fields as opaque data.
1077 */
1078static int gen_st_ops_shadow_type(const char *obj_name, struct btf *btf, const char *ident,
1079 const struct bpf_map *map)
1080{
1081 const struct btf_type *map_type;
1082 const char *type_name;
1083 __u32 map_type_id;
1084 int err;
1085
1086 map_type_id = bpf_map__btf_value_type_id(map);
1087 if (map_type_id == 0)
1088 return -EINVAL;
1089 map_type = btf__type_by_id(btf, map_type_id);
1090 if (!map_type)
1091 return -EINVAL;
1092
1093 type_name = btf__name_by_offset(btf, map_type->name_off);
1094
1095 printf("\t\tstruct %s__%s__%s {\n", obj_name, ident, type_name);
1096
1097 err = walk_st_ops_shadow_vars(btf, ident, map_type, map_type_id);
1098 if (err)
1099 return err;
1100
1101 printf("\t\t} *%s;\n", ident);
1102
1103 return 0;
1104}
1105
1106static int gen_st_ops_shadow(const char *obj_name, struct btf *btf, struct bpf_object *obj)
1107{
1108 int err, st_ops_cnt = 0;
1109 struct bpf_map *map;
1110 char ident[256];
1111
1112 if (!btf)
1113 return 0;
1114
1115 /* Generate the pointers to shadow types of
1116 * struct_ops maps.
1117 */
1118 bpf_object__for_each_map(map, obj) {
1119 if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS)
1120 continue;
1121 if (!get_map_ident(map, ident, sizeof(ident)))
1122 continue;
1123
1124 if (st_ops_cnt == 0) /* first struct_ops map */
1125 printf("\tstruct {\n");
1126 st_ops_cnt++;
1127
1128 err = gen_st_ops_shadow_type(obj_name, btf, ident, map);
1129 if (err)
1130 return err;
1131 }
1132
1133 if (st_ops_cnt)
1134 printf("\t} struct_ops;\n");
1135
1136 return 0;
1137}
1138
1139/* Generate the code to initialize the pointers of shadow types. */
1140static void gen_st_ops_shadow_init(struct btf *btf, struct bpf_object *obj)
1141{
1142 struct bpf_map *map;
1143 char ident[256];
1144
1145 if (!btf)
1146 return;
1147
1148 /* Initialize the pointers to_ops shadow types of
1149 * struct_ops maps.
1150 */
1151 bpf_object__for_each_map(map, obj) {
1152 if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS)
1153 continue;
1154 if (!get_map_ident(map, ident, sizeof(ident)))
1155 continue;
1156 codegen("\
1157 \n\
1158 obj->struct_ops.%1$s = (__typeof__(obj->struct_ops.%1$s))\n\
1159 bpf_map__initial_value(obj->maps.%1$s, NULL);\n\
1160 \n\
1161 ", ident);
1162 }
1163}
1164
1165static int do_skeleton(int argc, char **argv)
1166{
1167 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")];
1168 size_t map_cnt = 0, prog_cnt = 0, attach_map_cnt = 0, file_sz, mmap_sz;
1169 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
1170 char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data;
1171 struct bpf_object *obj = NULL;
1172 const char *file;
1173 char ident[256];
1174 struct bpf_program *prog;
1175 int fd, err = -1;
1176 struct bpf_map *map;
1177 struct btf *btf;
1178 struct stat st;
1179
1180 if (!REQ_ARGS(1)) {
1181 usage();
1182 return -1;
1183 }
1184 file = GET_ARG();
1185
1186 while (argc) {
1187 if (!REQ_ARGS(2))
1188 return -1;
1189
1190 if (is_prefix(*argv, "name")) {
1191 NEXT_ARG();
1192
1193 if (obj_name[0] != '\0') {
1194 p_err("object name already specified");
1195 return -1;
1196 }
1197
1198 strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1);
1199 obj_name[MAX_OBJ_NAME_LEN - 1] = '\0';
1200 } else {
1201 p_err("unknown arg %s", *argv);
1202 return -1;
1203 }
1204
1205 NEXT_ARG();
1206 }
1207
1208 if (argc) {
1209 p_err("extra unknown arguments");
1210 return -1;
1211 }
1212
1213 if (stat(file, &st)) {
1214 p_err("failed to stat() %s: %s", file, strerror(errno));
1215 return -1;
1216 }
1217 file_sz = st.st_size;
1218 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE));
1219 fd = open(file, O_RDONLY);
1220 if (fd < 0) {
1221 p_err("failed to open() %s: %s", file, strerror(errno));
1222 return -1;
1223 }
1224 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0);
1225 if (obj_data == MAP_FAILED) {
1226 obj_data = NULL;
1227 p_err("failed to mmap() %s: %s", file, strerror(errno));
1228 goto out;
1229 }
1230 if (obj_name[0] == '\0')
1231 get_obj_name(obj_name, file);
1232 opts.object_name = obj_name;
1233 if (verifier_logs)
1234 /* log_level1 + log_level2 + stats, but not stable UAPI */
1235 opts.kernel_log_level = 1 + 2 + 4;
1236 obj = bpf_object__open_mem(obj_data, file_sz, &opts);
1237 if (!obj) {
1238 char err_buf[256];
1239
1240 err = -errno;
1241 libbpf_strerror(err, err_buf, sizeof(err_buf));
1242 p_err("failed to open BPF object file: %s", err_buf);
1243 goto out;
1244 }
1245
1246 bpf_object__for_each_map(map, obj) {
1247 if (!get_map_ident(map, ident, sizeof(ident))) {
1248 p_err("ignoring unrecognized internal map '%s'...",
1249 bpf_map__name(map));
1250 continue;
1251 }
1252
1253 if (bpf_map__type(map) == BPF_MAP_TYPE_STRUCT_OPS)
1254 attach_map_cnt++;
1255
1256 map_cnt++;
1257 }
1258 bpf_object__for_each_program(prog, obj) {
1259 prog_cnt++;
1260 }
1261
1262 get_header_guard(header_guard, obj_name, "SKEL_H");
1263 if (use_loader) {
1264 codegen("\
1265 \n\
1266 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\
1267 /* THIS FILE IS AUTOGENERATED BY BPFTOOL! */ \n\
1268 #ifndef %2$s \n\
1269 #define %2$s \n\
1270 \n\
1271 #include <bpf/skel_internal.h> \n\
1272 \n\
1273 struct %1$s { \n\
1274 struct bpf_loader_ctx ctx; \n\
1275 ",
1276 obj_name, header_guard
1277 );
1278 } else {
1279 codegen("\
1280 \n\
1281 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\
1282 \n\
1283 /* THIS FILE IS AUTOGENERATED BY BPFTOOL! */ \n\
1284 #ifndef %2$s \n\
1285 #define %2$s \n\
1286 \n\
1287 #include <errno.h> \n\
1288 #include <stdlib.h> \n\
1289 #include <bpf/libbpf.h> \n\
1290 \n\
1291 #define BPF_SKEL_SUPPORTS_MAP_AUTO_ATTACH 1 \n\
1292 \n\
1293 struct %1$s { \n\
1294 struct bpf_object_skeleton *skeleton; \n\
1295 struct bpf_object *obj; \n\
1296 ",
1297 obj_name, header_guard
1298 );
1299 }
1300
1301 if (map_cnt) {
1302 printf("\tstruct {\n");
1303 bpf_object__for_each_map(map, obj) {
1304 if (!get_map_ident(map, ident, sizeof(ident)))
1305 continue;
1306 if (use_loader)
1307 printf("\t\tstruct bpf_map_desc %s;\n", ident);
1308 else
1309 printf("\t\tstruct bpf_map *%s;\n", ident);
1310 }
1311 printf("\t} maps;\n");
1312 }
1313
1314 btf = bpf_object__btf(obj);
1315 err = gen_st_ops_shadow(obj_name, btf, obj);
1316 if (err)
1317 goto out;
1318
1319 if (prog_cnt) {
1320 printf("\tstruct {\n");
1321 bpf_object__for_each_program(prog, obj) {
1322 if (use_loader)
1323 printf("\t\tstruct bpf_prog_desc %s;\n",
1324 bpf_program__name(prog));
1325 else
1326 printf("\t\tstruct bpf_program *%s;\n",
1327 bpf_program__name(prog));
1328 }
1329 printf("\t} progs;\n");
1330 }
1331
1332 if (prog_cnt + attach_map_cnt) {
1333 printf("\tstruct {\n");
1334 bpf_object__for_each_program(prog, obj) {
1335 if (use_loader)
1336 printf("\t\tint %s_fd;\n",
1337 bpf_program__name(prog));
1338 else
1339 printf("\t\tstruct bpf_link *%s;\n",
1340 bpf_program__name(prog));
1341 }
1342
1343 bpf_object__for_each_map(map, obj) {
1344 if (!get_map_ident(map, ident, sizeof(ident)))
1345 continue;
1346 if (bpf_map__type(map) != BPF_MAP_TYPE_STRUCT_OPS)
1347 continue;
1348
1349 if (use_loader)
1350 printf("t\tint %s_fd;\n", ident);
1351 else
1352 printf("\t\tstruct bpf_link *%s;\n", ident);
1353 }
1354
1355 printf("\t} links;\n");
1356 }
1357
1358 if (btf) {
1359 err = codegen_datasecs(obj, obj_name);
1360 if (err)
1361 goto out;
1362 }
1363 if (use_loader) {
1364 err = gen_trace(obj, obj_name, header_guard);
1365 goto out;
1366 }
1367
1368 codegen("\
1369 \n\
1370 \n\
1371 #ifdef __cplusplus \n\
1372 static inline struct %1$s *open(const struct bpf_object_open_opts *opts = nullptr);\n\
1373 static inline struct %1$s *open_and_load(); \n\
1374 static inline int load(struct %1$s *skel); \n\
1375 static inline int attach(struct %1$s *skel); \n\
1376 static inline void detach(struct %1$s *skel); \n\
1377 static inline void destroy(struct %1$s *skel); \n\
1378 static inline const void *elf_bytes(size_t *sz); \n\
1379 #endif /* __cplusplus */ \n\
1380 }; \n\
1381 \n\
1382 static void \n\
1383 %1$s__destroy(struct %1$s *obj) \n\
1384 { \n\
1385 if (!obj) \n\
1386 return; \n\
1387 if (obj->skeleton) \n\
1388 bpf_object__destroy_skeleton(obj->skeleton);\n\
1389 free(obj); \n\
1390 } \n\
1391 \n\
1392 static inline int \n\
1393 %1$s__create_skeleton(struct %1$s *obj); \n\
1394 \n\
1395 static inline struct %1$s * \n\
1396 %1$s__open_opts(const struct bpf_object_open_opts *opts) \n\
1397 { \n\
1398 struct %1$s *obj; \n\
1399 int err; \n\
1400 \n\
1401 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\
1402 if (!obj) { \n\
1403 errno = ENOMEM; \n\
1404 return NULL; \n\
1405 } \n\
1406 \n\
1407 err = %1$s__create_skeleton(obj); \n\
1408 if (err) \n\
1409 goto err_out; \n\
1410 \n\
1411 err = bpf_object__open_skeleton(obj->skeleton, opts);\n\
1412 if (err) \n\
1413 goto err_out; \n\
1414 \n\
1415 ", obj_name);
1416
1417 gen_st_ops_shadow_init(btf, obj);
1418
1419 codegen("\
1420 \n\
1421 return obj; \n\
1422 err_out: \n\
1423 %1$s__destroy(obj); \n\
1424 errno = -err; \n\
1425 return NULL; \n\
1426 } \n\
1427 \n\
1428 static inline struct %1$s * \n\
1429 %1$s__open(void) \n\
1430 { \n\
1431 return %1$s__open_opts(NULL); \n\
1432 } \n\
1433 \n\
1434 static inline int \n\
1435 %1$s__load(struct %1$s *obj) \n\
1436 { \n\
1437 return bpf_object__load_skeleton(obj->skeleton); \n\
1438 } \n\
1439 \n\
1440 static inline struct %1$s * \n\
1441 %1$s__open_and_load(void) \n\
1442 { \n\
1443 struct %1$s *obj; \n\
1444 int err; \n\
1445 \n\
1446 obj = %1$s__open(); \n\
1447 if (!obj) \n\
1448 return NULL; \n\
1449 err = %1$s__load(obj); \n\
1450 if (err) { \n\
1451 %1$s__destroy(obj); \n\
1452 errno = -err; \n\
1453 return NULL; \n\
1454 } \n\
1455 return obj; \n\
1456 } \n\
1457 \n\
1458 static inline int \n\
1459 %1$s__attach(struct %1$s *obj) \n\
1460 { \n\
1461 return bpf_object__attach_skeleton(obj->skeleton); \n\
1462 } \n\
1463 \n\
1464 static inline void \n\
1465 %1$s__detach(struct %1$s *obj) \n\
1466 { \n\
1467 bpf_object__detach_skeleton(obj->skeleton); \n\
1468 } \n\
1469 ",
1470 obj_name
1471 );
1472
1473 codegen("\
1474 \n\
1475 \n\
1476 static inline const void *%1$s__elf_bytes(size_t *sz); \n\
1477 \n\
1478 static inline int \n\
1479 %1$s__create_skeleton(struct %1$s *obj) \n\
1480 { \n\
1481 struct bpf_object_skeleton *s; \n\
1482 struct bpf_map_skeleton *map __attribute__((unused));\n\
1483 int err; \n\
1484 \n\
1485 s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\
1486 if (!s) { \n\
1487 err = -ENOMEM; \n\
1488 goto err; \n\
1489 } \n\
1490 \n\
1491 s->sz = sizeof(*s); \n\
1492 s->name = \"%1$s\"; \n\
1493 s->obj = &obj->obj; \n\
1494 ",
1495 obj_name
1496 );
1497
1498 codegen_maps_skeleton(obj, map_cnt, true /*mmaped*/, true /*links*/);
1499 codegen_progs_skeleton(obj, prog_cnt, true /*populate_links*/);
1500
1501 codegen("\
1502 \n\
1503 \n\
1504 s->data = %1$s__elf_bytes(&s->data_sz); \n\
1505 \n\
1506 obj->skeleton = s; \n\
1507 return 0; \n\
1508 err: \n\
1509 bpf_object__destroy_skeleton(s); \n\
1510 return err; \n\
1511 } \n\
1512 \n\
1513 static inline const void *%1$s__elf_bytes(size_t *sz) \n\
1514 { \n\
1515 static const char data[] __attribute__((__aligned__(8))) = \"\\\n\
1516 ",
1517 obj_name
1518 );
1519
1520 /* embed contents of BPF object file */
1521 print_hex(obj_data, file_sz);
1522
1523 codegen("\
1524 \n\
1525 \"; \n\
1526 \n\
1527 *sz = sizeof(data) - 1; \n\
1528 return (const void *)data; \n\
1529 } \n\
1530 \n\
1531 #ifdef __cplusplus \n\
1532 struct %1$s *%1$s::open(const struct bpf_object_open_opts *opts) { return %1$s__open_opts(opts); }\n\
1533 struct %1$s *%1$s::open_and_load() { return %1$s__open_and_load(); } \n\
1534 int %1$s::load(struct %1$s *skel) { return %1$s__load(skel); } \n\
1535 int %1$s::attach(struct %1$s *skel) { return %1$s__attach(skel); } \n\
1536 void %1$s::detach(struct %1$s *skel) { %1$s__detach(skel); } \n\
1537 void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); } \n\
1538 const void *%1$s::elf_bytes(size_t *sz) { return %1$s__elf_bytes(sz); } \n\
1539 #endif /* __cplusplus */ \n\
1540 \n\
1541 ",
1542 obj_name);
1543
1544 codegen_asserts(obj, obj_name);
1545
1546 codegen("\
1547 \n\
1548 \n\
1549 #endif /* %1$s */ \n\
1550 ",
1551 header_guard);
1552 err = 0;
1553out:
1554 bpf_object__close(obj);
1555 if (obj_data)
1556 munmap(obj_data, mmap_sz);
1557 close(fd);
1558 return err;
1559}
1560
1561/* Subskeletons are like skeletons, except they don't own the bpf_object,
1562 * associated maps, links, etc. Instead, they know about the existence of
1563 * variables, maps, programs and are able to find their locations
1564 * _at runtime_ from an already loaded bpf_object.
1565 *
1566 * This allows for library-like BPF objects to have userspace counterparts
1567 * with access to their own items without having to know anything about the
1568 * final BPF object that the library was linked into.
1569 */
1570static int do_subskeleton(int argc, char **argv)
1571{
1572 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SUBSKEL_H__")];
1573 size_t i, len, file_sz, map_cnt = 0, prog_cnt = 0, mmap_sz, var_cnt = 0, var_idx = 0;
1574 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
1575 char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data;
1576 struct bpf_object *obj = NULL;
1577 const char *file, *var_name;
1578 char ident[256];
1579 int fd, err = -1, map_type_id;
1580 const struct bpf_map *map;
1581 struct bpf_program *prog;
1582 struct btf *btf;
1583 const struct btf_type *map_type, *var_type;
1584 const struct btf_var_secinfo *var;
1585 struct stat st;
1586
1587 if (!REQ_ARGS(1)) {
1588 usage();
1589 return -1;
1590 }
1591 file = GET_ARG();
1592
1593 while (argc) {
1594 if (!REQ_ARGS(2))
1595 return -1;
1596
1597 if (is_prefix(*argv, "name")) {
1598 NEXT_ARG();
1599
1600 if (obj_name[0] != '\0') {
1601 p_err("object name already specified");
1602 return -1;
1603 }
1604
1605 strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1);
1606 obj_name[MAX_OBJ_NAME_LEN - 1] = '\0';
1607 } else {
1608 p_err("unknown arg %s", *argv);
1609 return -1;
1610 }
1611
1612 NEXT_ARG();
1613 }
1614
1615 if (argc) {
1616 p_err("extra unknown arguments");
1617 return -1;
1618 }
1619
1620 if (use_loader) {
1621 p_err("cannot use loader for subskeletons");
1622 return -1;
1623 }
1624
1625 if (stat(file, &st)) {
1626 p_err("failed to stat() %s: %s", file, strerror(errno));
1627 return -1;
1628 }
1629 file_sz = st.st_size;
1630 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE));
1631 fd = open(file, O_RDONLY);
1632 if (fd < 0) {
1633 p_err("failed to open() %s: %s", file, strerror(errno));
1634 return -1;
1635 }
1636 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0);
1637 if (obj_data == MAP_FAILED) {
1638 obj_data = NULL;
1639 p_err("failed to mmap() %s: %s", file, strerror(errno));
1640 goto out;
1641 }
1642 if (obj_name[0] == '\0')
1643 get_obj_name(obj_name, file);
1644
1645 /* The empty object name allows us to use bpf_map__name and produce
1646 * ELF section names out of it. (".data" instead of "obj.data")
1647 */
1648 opts.object_name = "";
1649 obj = bpf_object__open_mem(obj_data, file_sz, &opts);
1650 if (!obj) {
1651 char err_buf[256];
1652
1653 libbpf_strerror(errno, err_buf, sizeof(err_buf));
1654 p_err("failed to open BPF object file: %s", err_buf);
1655 obj = NULL;
1656 goto out;
1657 }
1658
1659 btf = bpf_object__btf(obj);
1660 if (!btf) {
1661 err = -1;
1662 p_err("need btf type information for %s", obj_name);
1663 goto out;
1664 }
1665
1666 bpf_object__for_each_program(prog, obj) {
1667 prog_cnt++;
1668 }
1669
1670 /* First, count how many variables we have to find.
1671 * We need this in advance so the subskel can allocate the right
1672 * amount of storage.
1673 */
1674 bpf_object__for_each_map(map, obj) {
1675 if (!get_map_ident(map, ident, sizeof(ident)))
1676 continue;
1677
1678 /* Also count all maps that have a name */
1679 map_cnt++;
1680
1681 if (!is_mmapable_map(map, ident, sizeof(ident)))
1682 continue;
1683
1684 map_type_id = bpf_map__btf_value_type_id(map);
1685 if (map_type_id <= 0) {
1686 err = map_type_id;
1687 goto out;
1688 }
1689 map_type = btf__type_by_id(btf, map_type_id);
1690
1691 var = btf_var_secinfos(map_type);
1692 len = btf_vlen(map_type);
1693 for (i = 0; i < len; i++, var++) {
1694 var_type = btf__type_by_id(btf, var->type);
1695
1696 if (btf_var(var_type)->linkage == BTF_VAR_STATIC)
1697 continue;
1698
1699 var_cnt++;
1700 }
1701 }
1702
1703 get_header_guard(header_guard, obj_name, "SUBSKEL_H");
1704 codegen("\
1705 \n\
1706 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\
1707 \n\
1708 /* THIS FILE IS AUTOGENERATED! */ \n\
1709 #ifndef %2$s \n\
1710 #define %2$s \n\
1711 \n\
1712 #include <errno.h> \n\
1713 #include <stdlib.h> \n\
1714 #include <bpf/libbpf.h> \n\
1715 \n\
1716 struct %1$s { \n\
1717 struct bpf_object *obj; \n\
1718 struct bpf_object_subskeleton *subskel; \n\
1719 ", obj_name, header_guard);
1720
1721 if (map_cnt) {
1722 printf("\tstruct {\n");
1723 bpf_object__for_each_map(map, obj) {
1724 if (!get_map_ident(map, ident, sizeof(ident)))
1725 continue;
1726 printf("\t\tstruct bpf_map *%s;\n", ident);
1727 }
1728 printf("\t} maps;\n");
1729 }
1730
1731 err = gen_st_ops_shadow(obj_name, btf, obj);
1732 if (err)
1733 goto out;
1734
1735 if (prog_cnt) {
1736 printf("\tstruct {\n");
1737 bpf_object__for_each_program(prog, obj) {
1738 printf("\t\tstruct bpf_program *%s;\n",
1739 bpf_program__name(prog));
1740 }
1741 printf("\t} progs;\n");
1742 }
1743
1744 err = codegen_subskel_datasecs(obj, obj_name);
1745 if (err)
1746 goto out;
1747
1748 /* emit code that will allocate enough storage for all symbols */
1749 codegen("\
1750 \n\
1751 \n\
1752 #ifdef __cplusplus \n\
1753 static inline struct %1$s *open(const struct bpf_object *src);\n\
1754 static inline void destroy(struct %1$s *skel); \n\
1755 #endif /* __cplusplus */ \n\
1756 }; \n\
1757 \n\
1758 static inline void \n\
1759 %1$s__destroy(struct %1$s *skel) \n\
1760 { \n\
1761 if (!skel) \n\
1762 return; \n\
1763 if (skel->subskel) \n\
1764 bpf_object__destroy_subskeleton(skel->subskel);\n\
1765 free(skel); \n\
1766 } \n\
1767 \n\
1768 static inline struct %1$s * \n\
1769 %1$s__open(const struct bpf_object *src) \n\
1770 { \n\
1771 struct %1$s *obj; \n\
1772 struct bpf_object_subskeleton *s; \n\
1773 struct bpf_map_skeleton *map __attribute__((unused));\n\
1774 int err; \n\
1775 \n\
1776 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\
1777 if (!obj) { \n\
1778 err = -ENOMEM; \n\
1779 goto err; \n\
1780 } \n\
1781 s = (struct bpf_object_subskeleton *)calloc(1, sizeof(*s));\n\
1782 if (!s) { \n\
1783 err = -ENOMEM; \n\
1784 goto err; \n\
1785 } \n\
1786 s->sz = sizeof(*s); \n\
1787 s->obj = src; \n\
1788 s->var_skel_sz = sizeof(*s->vars); \n\
1789 obj->subskel = s; \n\
1790 \n\
1791 /* vars */ \n\
1792 s->var_cnt = %2$d; \n\
1793 s->vars = (struct bpf_var_skeleton *)calloc(%2$d, sizeof(*s->vars));\n\
1794 if (!s->vars) { \n\
1795 err = -ENOMEM; \n\
1796 goto err; \n\
1797 } \n\
1798 ",
1799 obj_name, var_cnt
1800 );
1801
1802 /* walk through each symbol and emit the runtime representation */
1803 bpf_object__for_each_map(map, obj) {
1804 if (!is_mmapable_map(map, ident, sizeof(ident)))
1805 continue;
1806
1807 map_type_id = bpf_map__btf_value_type_id(map);
1808 if (map_type_id <= 0)
1809 /* skip over internal maps with no type*/
1810 continue;
1811
1812 map_type = btf__type_by_id(btf, map_type_id);
1813 var = btf_var_secinfos(map_type);
1814 len = btf_vlen(map_type);
1815 for (i = 0; i < len; i++, var++) {
1816 var_type = btf__type_by_id(btf, var->type);
1817 var_name = btf__name_by_offset(btf, var_type->name_off);
1818
1819 if (btf_var(var_type)->linkage == BTF_VAR_STATIC)
1820 continue;
1821
1822 /* Note that we use the dot prefix in .data as the
1823 * field access operator i.e. maps%s becomes maps.data
1824 */
1825 codegen("\
1826 \n\
1827 \n\
1828 s->vars[%3$d].name = \"%1$s\"; \n\
1829 s->vars[%3$d].map = &obj->maps.%2$s; \n\
1830 s->vars[%3$d].addr = (void **) &obj->%2$s.%1$s;\n\
1831 ", var_name, ident, var_idx);
1832
1833 var_idx++;
1834 }
1835 }
1836
1837 codegen_maps_skeleton(obj, map_cnt, false /*mmaped*/, false /*links*/);
1838 codegen_progs_skeleton(obj, prog_cnt, false /*links*/);
1839
1840 codegen("\
1841 \n\
1842 \n\
1843 err = bpf_object__open_subskeleton(s); \n\
1844 if (err) \n\
1845 goto err; \n\
1846 \n\
1847 ");
1848
1849 gen_st_ops_shadow_init(btf, obj);
1850
1851 codegen("\
1852 \n\
1853 return obj; \n\
1854 err: \n\
1855 %1$s__destroy(obj); \n\
1856 errno = -err; \n\
1857 return NULL; \n\
1858 } \n\
1859 \n\
1860 #ifdef __cplusplus \n\
1861 struct %1$s *%1$s::open(const struct bpf_object *src) { return %1$s__open(src); }\n\
1862 void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); }\n\
1863 #endif /* __cplusplus */ \n\
1864 \n\
1865 #endif /* %2$s */ \n\
1866 ",
1867 obj_name, header_guard);
1868 err = 0;
1869out:
1870 bpf_object__close(obj);
1871 if (obj_data)
1872 munmap(obj_data, mmap_sz);
1873 close(fd);
1874 return err;
1875}
1876
1877static int do_object(int argc, char **argv)
1878{
1879 struct bpf_linker *linker;
1880 const char *output_file, *file;
1881 int err = 0;
1882
1883 if (!REQ_ARGS(2)) {
1884 usage();
1885 return -1;
1886 }
1887
1888 output_file = GET_ARG();
1889
1890 linker = bpf_linker__new(output_file, NULL);
1891 if (!linker) {
1892 p_err("failed to create BPF linker instance");
1893 return -1;
1894 }
1895
1896 while (argc) {
1897 file = GET_ARG();
1898
1899 err = bpf_linker__add_file(linker, file, NULL);
1900 if (err) {
1901 p_err("failed to link '%s': %s (%d)", file, strerror(errno), errno);
1902 goto out;
1903 }
1904 }
1905
1906 err = bpf_linker__finalize(linker);
1907 if (err) {
1908 p_err("failed to finalize ELF file: %s (%d)", strerror(errno), errno);
1909 goto out;
1910 }
1911
1912 err = 0;
1913out:
1914 bpf_linker__free(linker);
1915 return err;
1916}
1917
1918static int do_help(int argc, char **argv)
1919{
1920 if (json_output) {
1921 jsonw_null(json_wtr);
1922 return 0;
1923 }
1924
1925 fprintf(stderr,
1926 "Usage: %1$s %2$s object OUTPUT_FILE INPUT_FILE [INPUT_FILE...]\n"
1927 " %1$s %2$s skeleton FILE [name OBJECT_NAME]\n"
1928 " %1$s %2$s subskeleton FILE [name OBJECT_NAME]\n"
1929 " %1$s %2$s min_core_btf INPUT OUTPUT OBJECT [OBJECT...]\n"
1930 " %1$s %2$s help\n"
1931 "\n"
1932 " " HELP_SPEC_OPTIONS " |\n"
1933 " {-L|--use-loader} }\n"
1934 "",
1935 bin_name, "gen");
1936
1937 return 0;
1938}
1939
1940static int btf_save_raw(const struct btf *btf, const char *path)
1941{
1942 const void *data;
1943 FILE *f = NULL;
1944 __u32 data_sz;
1945 int err = 0;
1946
1947 data = btf__raw_data(btf, &data_sz);
1948 if (!data)
1949 return -ENOMEM;
1950
1951 f = fopen(path, "wb");
1952 if (!f)
1953 return -errno;
1954
1955 if (fwrite(data, 1, data_sz, f) != data_sz)
1956 err = -errno;
1957
1958 fclose(f);
1959 return err;
1960}
1961
1962struct btfgen_info {
1963 struct btf *src_btf;
1964 struct btf *marked_btf; /* btf structure used to mark used types */
1965};
1966
1967static size_t btfgen_hash_fn(long key, void *ctx)
1968{
1969 return key;
1970}
1971
1972static bool btfgen_equal_fn(long k1, long k2, void *ctx)
1973{
1974 return k1 == k2;
1975}
1976
1977static void btfgen_free_info(struct btfgen_info *info)
1978{
1979 if (!info)
1980 return;
1981
1982 btf__free(info->src_btf);
1983 btf__free(info->marked_btf);
1984
1985 free(info);
1986}
1987
1988static struct btfgen_info *
1989btfgen_new_info(const char *targ_btf_path)
1990{
1991 struct btfgen_info *info;
1992 int err;
1993
1994 info = calloc(1, sizeof(*info));
1995 if (!info)
1996 return NULL;
1997
1998 info->src_btf = btf__parse(targ_btf_path, NULL);
1999 if (!info->src_btf) {
2000 err = -errno;
2001 p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno));
2002 goto err_out;
2003 }
2004
2005 info->marked_btf = btf__parse(targ_btf_path, NULL);
2006 if (!info->marked_btf) {
2007 err = -errno;
2008 p_err("failed parsing '%s' BTF file: %s", targ_btf_path, strerror(errno));
2009 goto err_out;
2010 }
2011
2012 return info;
2013
2014err_out:
2015 btfgen_free_info(info);
2016 errno = -err;
2017 return NULL;
2018}
2019
2020#define MARKED UINT32_MAX
2021
2022static void btfgen_mark_member(struct btfgen_info *info, int type_id, int idx)
2023{
2024 const struct btf_type *t = btf__type_by_id(info->marked_btf, type_id);
2025 struct btf_member *m = btf_members(t) + idx;
2026
2027 m->name_off = MARKED;
2028}
2029
2030static int
2031btfgen_mark_type(struct btfgen_info *info, unsigned int type_id, bool follow_pointers)
2032{
2033 const struct btf_type *btf_type = btf__type_by_id(info->src_btf, type_id);
2034 struct btf_type *cloned_type;
2035 struct btf_param *param;
2036 struct btf_array *array;
2037 int err, i;
2038
2039 if (type_id == 0)
2040 return 0;
2041
2042 /* mark type on cloned BTF as used */
2043 cloned_type = (struct btf_type *) btf__type_by_id(info->marked_btf, type_id);
2044 cloned_type->name_off = MARKED;
2045
2046 /* recursively mark other types needed by it */
2047 switch (btf_kind(btf_type)) {
2048 case BTF_KIND_UNKN:
2049 case BTF_KIND_INT:
2050 case BTF_KIND_FLOAT:
2051 case BTF_KIND_ENUM:
2052 case BTF_KIND_ENUM64:
2053 case BTF_KIND_STRUCT:
2054 case BTF_KIND_UNION:
2055 break;
2056 case BTF_KIND_PTR:
2057 if (follow_pointers) {
2058 err = btfgen_mark_type(info, btf_type->type, follow_pointers);
2059 if (err)
2060 return err;
2061 }
2062 break;
2063 case BTF_KIND_CONST:
2064 case BTF_KIND_RESTRICT:
2065 case BTF_KIND_VOLATILE:
2066 case BTF_KIND_TYPEDEF:
2067 err = btfgen_mark_type(info, btf_type->type, follow_pointers);
2068 if (err)
2069 return err;
2070 break;
2071 case BTF_KIND_ARRAY:
2072 array = btf_array(btf_type);
2073
2074 /* mark array type */
2075 err = btfgen_mark_type(info, array->type, follow_pointers);
2076 /* mark array's index type */
2077 err = err ? : btfgen_mark_type(info, array->index_type, follow_pointers);
2078 if (err)
2079 return err;
2080 break;
2081 case BTF_KIND_FUNC_PROTO:
2082 /* mark ret type */
2083 err = btfgen_mark_type(info, btf_type->type, follow_pointers);
2084 if (err)
2085 return err;
2086
2087 /* mark parameters types */
2088 param = btf_params(btf_type);
2089 for (i = 0; i < btf_vlen(btf_type); i++) {
2090 err = btfgen_mark_type(info, param->type, follow_pointers);
2091 if (err)
2092 return err;
2093 param++;
2094 }
2095 break;
2096 /* tells if some other type needs to be handled */
2097 default:
2098 p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id);
2099 return -EINVAL;
2100 }
2101
2102 return 0;
2103}
2104
2105static int btfgen_record_field_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
2106{
2107 struct btf *btf = info->src_btf;
2108 const struct btf_type *btf_type;
2109 struct btf_member *btf_member;
2110 struct btf_array *array;
2111 unsigned int type_id = targ_spec->root_type_id;
2112 int idx, err;
2113
2114 /* mark root type */
2115 btf_type = btf__type_by_id(btf, type_id);
2116 err = btfgen_mark_type(info, type_id, false);
2117 if (err)
2118 return err;
2119
2120 /* mark types for complex types (arrays, unions, structures) */
2121 for (int i = 1; i < targ_spec->raw_len; i++) {
2122 /* skip typedefs and mods */
2123 while (btf_is_mod(btf_type) || btf_is_typedef(btf_type)) {
2124 type_id = btf_type->type;
2125 btf_type = btf__type_by_id(btf, type_id);
2126 }
2127
2128 switch (btf_kind(btf_type)) {
2129 case BTF_KIND_STRUCT:
2130 case BTF_KIND_UNION:
2131 idx = targ_spec->raw_spec[i];
2132 btf_member = btf_members(btf_type) + idx;
2133
2134 /* mark member */
2135 btfgen_mark_member(info, type_id, idx);
2136
2137 /* mark member's type */
2138 type_id = btf_member->type;
2139 btf_type = btf__type_by_id(btf, type_id);
2140 err = btfgen_mark_type(info, type_id, false);
2141 if (err)
2142 return err;
2143 break;
2144 case BTF_KIND_ARRAY:
2145 array = btf_array(btf_type);
2146 type_id = array->type;
2147 btf_type = btf__type_by_id(btf, type_id);
2148 break;
2149 default:
2150 p_err("unsupported kind: %s (%d)",
2151 btf_kind_str(btf_type), btf_type->type);
2152 return -EINVAL;
2153 }
2154 }
2155
2156 return 0;
2157}
2158
2159/* Mark types, members, and member types. Compared to btfgen_record_field_relo,
2160 * this function does not rely on the target spec for inferring members, but
2161 * uses the associated BTF.
2162 *
2163 * The `behind_ptr` argument is used to stop marking of composite types reached
2164 * through a pointer. This way, we can keep BTF size in check while providing
2165 * reasonable match semantics.
2166 */
2167static int btfgen_mark_type_match(struct btfgen_info *info, __u32 type_id, bool behind_ptr)
2168{
2169 const struct btf_type *btf_type;
2170 struct btf *btf = info->src_btf;
2171 struct btf_type *cloned_type;
2172 int i, err;
2173
2174 if (type_id == 0)
2175 return 0;
2176
2177 btf_type = btf__type_by_id(btf, type_id);
2178 /* mark type on cloned BTF as used */
2179 cloned_type = (struct btf_type *)btf__type_by_id(info->marked_btf, type_id);
2180 cloned_type->name_off = MARKED;
2181
2182 switch (btf_kind(btf_type)) {
2183 case BTF_KIND_UNKN:
2184 case BTF_KIND_INT:
2185 case BTF_KIND_FLOAT:
2186 case BTF_KIND_ENUM:
2187 case BTF_KIND_ENUM64:
2188 break;
2189 case BTF_KIND_STRUCT:
2190 case BTF_KIND_UNION: {
2191 struct btf_member *m = btf_members(btf_type);
2192 __u16 vlen = btf_vlen(btf_type);
2193
2194 if (behind_ptr)
2195 break;
2196
2197 for (i = 0; i < vlen; i++, m++) {
2198 /* mark member */
2199 btfgen_mark_member(info, type_id, i);
2200
2201 /* mark member's type */
2202 err = btfgen_mark_type_match(info, m->type, false);
2203 if (err)
2204 return err;
2205 }
2206 break;
2207 }
2208 case BTF_KIND_CONST:
2209 case BTF_KIND_FWD:
2210 case BTF_KIND_RESTRICT:
2211 case BTF_KIND_TYPEDEF:
2212 case BTF_KIND_VOLATILE:
2213 return btfgen_mark_type_match(info, btf_type->type, behind_ptr);
2214 case BTF_KIND_PTR:
2215 return btfgen_mark_type_match(info, btf_type->type, true);
2216 case BTF_KIND_ARRAY: {
2217 struct btf_array *array;
2218
2219 array = btf_array(btf_type);
2220 /* mark array type */
2221 err = btfgen_mark_type_match(info, array->type, false);
2222 /* mark array's index type */
2223 err = err ? : btfgen_mark_type_match(info, array->index_type, false);
2224 if (err)
2225 return err;
2226 break;
2227 }
2228 case BTF_KIND_FUNC_PROTO: {
2229 __u16 vlen = btf_vlen(btf_type);
2230 struct btf_param *param;
2231
2232 /* mark ret type */
2233 err = btfgen_mark_type_match(info, btf_type->type, false);
2234 if (err)
2235 return err;
2236
2237 /* mark parameters types */
2238 param = btf_params(btf_type);
2239 for (i = 0; i < vlen; i++) {
2240 err = btfgen_mark_type_match(info, param->type, false);
2241 if (err)
2242 return err;
2243 param++;
2244 }
2245 break;
2246 }
2247 /* tells if some other type needs to be handled */
2248 default:
2249 p_err("unsupported kind: %s (%d)", btf_kind_str(btf_type), type_id);
2250 return -EINVAL;
2251 }
2252
2253 return 0;
2254}
2255
2256/* Mark types, members, and member types. Compared to btfgen_record_field_relo,
2257 * this function does not rely on the target spec for inferring members, but
2258 * uses the associated BTF.
2259 */
2260static int btfgen_record_type_match_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
2261{
2262 return btfgen_mark_type_match(info, targ_spec->root_type_id, false);
2263}
2264
2265static int btfgen_record_type_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
2266{
2267 return btfgen_mark_type(info, targ_spec->root_type_id, true);
2268}
2269
2270static int btfgen_record_enumval_relo(struct btfgen_info *info, struct bpf_core_spec *targ_spec)
2271{
2272 return btfgen_mark_type(info, targ_spec->root_type_id, false);
2273}
2274
2275static int btfgen_record_reloc(struct btfgen_info *info, struct bpf_core_spec *res)
2276{
2277 switch (res->relo_kind) {
2278 case BPF_CORE_FIELD_BYTE_OFFSET:
2279 case BPF_CORE_FIELD_BYTE_SIZE:
2280 case BPF_CORE_FIELD_EXISTS:
2281 case BPF_CORE_FIELD_SIGNED:
2282 case BPF_CORE_FIELD_LSHIFT_U64:
2283 case BPF_CORE_FIELD_RSHIFT_U64:
2284 return btfgen_record_field_relo(info, res);
2285 case BPF_CORE_TYPE_ID_LOCAL: /* BPF_CORE_TYPE_ID_LOCAL doesn't require kernel BTF */
2286 return 0;
2287 case BPF_CORE_TYPE_ID_TARGET:
2288 case BPF_CORE_TYPE_EXISTS:
2289 case BPF_CORE_TYPE_SIZE:
2290 return btfgen_record_type_relo(info, res);
2291 case BPF_CORE_TYPE_MATCHES:
2292 return btfgen_record_type_match_relo(info, res);
2293 case BPF_CORE_ENUMVAL_EXISTS:
2294 case BPF_CORE_ENUMVAL_VALUE:
2295 return btfgen_record_enumval_relo(info, res);
2296 default:
2297 return -EINVAL;
2298 }
2299}
2300
2301static struct bpf_core_cand_list *
2302btfgen_find_cands(const struct btf *local_btf, const struct btf *targ_btf, __u32 local_id)
2303{
2304 const struct btf_type *local_type;
2305 struct bpf_core_cand_list *cands = NULL;
2306 struct bpf_core_cand local_cand = {};
2307 size_t local_essent_len;
2308 const char *local_name;
2309 int err;
2310
2311 local_cand.btf = local_btf;
2312 local_cand.id = local_id;
2313
2314 local_type = btf__type_by_id(local_btf, local_id);
2315 if (!local_type) {
2316 err = -EINVAL;
2317 goto err_out;
2318 }
2319
2320 local_name = btf__name_by_offset(local_btf, local_type->name_off);
2321 if (!local_name) {
2322 err = -EINVAL;
2323 goto err_out;
2324 }
2325 local_essent_len = bpf_core_essential_name_len(local_name);
2326
2327 cands = calloc(1, sizeof(*cands));
2328 if (!cands)
2329 return NULL;
2330
2331 err = bpf_core_add_cands(&local_cand, local_essent_len, targ_btf, "vmlinux", 1, cands);
2332 if (err)
2333 goto err_out;
2334
2335 return cands;
2336
2337err_out:
2338 bpf_core_free_cands(cands);
2339 errno = -err;
2340 return NULL;
2341}
2342
2343/* Record relocation information for a single BPF object */
2344static int btfgen_record_obj(struct btfgen_info *info, const char *obj_path)
2345{
2346 const struct btf_ext_info_sec *sec;
2347 const struct bpf_core_relo *relo;
2348 const struct btf_ext_info *seg;
2349 struct hashmap_entry *entry;
2350 struct hashmap *cand_cache = NULL;
2351 struct btf_ext *btf_ext = NULL;
2352 unsigned int relo_idx;
2353 struct btf *btf = NULL;
2354 size_t i;
2355 int err;
2356
2357 btf = btf__parse(obj_path, &btf_ext);
2358 if (!btf) {
2359 err = -errno;
2360 p_err("failed to parse BPF object '%s': %s", obj_path, strerror(errno));
2361 return err;
2362 }
2363
2364 if (!btf_ext) {
2365 p_err("failed to parse BPF object '%s': section %s not found",
2366 obj_path, BTF_EXT_ELF_SEC);
2367 err = -EINVAL;
2368 goto out;
2369 }
2370
2371 if (btf_ext->core_relo_info.len == 0) {
2372 err = 0;
2373 goto out;
2374 }
2375
2376 cand_cache = hashmap__new(btfgen_hash_fn, btfgen_equal_fn, NULL);
2377 if (IS_ERR(cand_cache)) {
2378 err = PTR_ERR(cand_cache);
2379 goto out;
2380 }
2381
2382 seg = &btf_ext->core_relo_info;
2383 for_each_btf_ext_sec(seg, sec) {
2384 for_each_btf_ext_rec(seg, sec, relo_idx, relo) {
2385 struct bpf_core_spec specs_scratch[3] = {};
2386 struct bpf_core_relo_res targ_res = {};
2387 struct bpf_core_cand_list *cands = NULL;
2388 const char *sec_name = btf__name_by_offset(btf, sec->sec_name_off);
2389
2390 if (relo->kind != BPF_CORE_TYPE_ID_LOCAL &&
2391 !hashmap__find(cand_cache, relo->type_id, &cands)) {
2392 cands = btfgen_find_cands(btf, info->src_btf, relo->type_id);
2393 if (!cands) {
2394 err = -errno;
2395 goto out;
2396 }
2397
2398 err = hashmap__set(cand_cache, relo->type_id, cands,
2399 NULL, NULL);
2400 if (err)
2401 goto out;
2402 }
2403
2404 err = bpf_core_calc_relo_insn(sec_name, relo, relo_idx, btf, cands,
2405 specs_scratch, &targ_res);
2406 if (err)
2407 goto out;
2408
2409 /* specs_scratch[2] is the target spec */
2410 err = btfgen_record_reloc(info, &specs_scratch[2]);
2411 if (err)
2412 goto out;
2413 }
2414 }
2415
2416out:
2417 btf__free(btf);
2418 btf_ext__free(btf_ext);
2419
2420 if (!IS_ERR_OR_NULL(cand_cache)) {
2421 hashmap__for_each_entry(cand_cache, entry, i) {
2422 bpf_core_free_cands(entry->pvalue);
2423 }
2424 hashmap__free(cand_cache);
2425 }
2426
2427 return err;
2428}
2429
2430/* Generate BTF from relocation information previously recorded */
2431static struct btf *btfgen_get_btf(struct btfgen_info *info)
2432{
2433 struct btf *btf_new = NULL;
2434 unsigned int *ids = NULL;
2435 unsigned int i, n = btf__type_cnt(info->marked_btf);
2436 int err = 0;
2437
2438 btf_new = btf__new_empty();
2439 if (!btf_new) {
2440 err = -errno;
2441 goto err_out;
2442 }
2443
2444 ids = calloc(n, sizeof(*ids));
2445 if (!ids) {
2446 err = -errno;
2447 goto err_out;
2448 }
2449
2450 /* first pass: add all marked types to btf_new and add their new ids to the ids map */
2451 for (i = 1; i < n; i++) {
2452 const struct btf_type *cloned_type, *type;
2453 const char *name;
2454 int new_id;
2455
2456 cloned_type = btf__type_by_id(info->marked_btf, i);
2457
2458 if (cloned_type->name_off != MARKED)
2459 continue;
2460
2461 type = btf__type_by_id(info->src_btf, i);
2462
2463 /* add members for struct and union */
2464 if (btf_is_composite(type)) {
2465 struct btf_member *cloned_m, *m;
2466 unsigned short vlen;
2467 int idx_src;
2468
2469 name = btf__str_by_offset(info->src_btf, type->name_off);
2470
2471 if (btf_is_struct(type))
2472 err = btf__add_struct(btf_new, name, type->size);
2473 else
2474 err = btf__add_union(btf_new, name, type->size);
2475
2476 if (err < 0)
2477 goto err_out;
2478 new_id = err;
2479
2480 cloned_m = btf_members(cloned_type);
2481 m = btf_members(type);
2482 vlen = btf_vlen(cloned_type);
2483 for (idx_src = 0; idx_src < vlen; idx_src++, cloned_m++, m++) {
2484 /* add only members that are marked as used */
2485 if (cloned_m->name_off != MARKED)
2486 continue;
2487
2488 name = btf__str_by_offset(info->src_btf, m->name_off);
2489 err = btf__add_field(btf_new, name, m->type,
2490 btf_member_bit_offset(cloned_type, idx_src),
2491 btf_member_bitfield_size(cloned_type, idx_src));
2492 if (err < 0)
2493 goto err_out;
2494 }
2495 } else {
2496 err = btf__add_type(btf_new, info->src_btf, type);
2497 if (err < 0)
2498 goto err_out;
2499 new_id = err;
2500 }
2501
2502 /* add ID mapping */
2503 ids[i] = new_id;
2504 }
2505
2506 /* second pass: fix up type ids */
2507 for (i = 1; i < btf__type_cnt(btf_new); i++) {
2508 struct btf_type *btf_type = (struct btf_type *) btf__type_by_id(btf_new, i);
2509 struct btf_field_iter it;
2510 __u32 *type_id;
2511
2512 err = btf_field_iter_init(&it, btf_type, BTF_FIELD_ITER_IDS);
2513 if (err)
2514 goto err_out;
2515
2516 while ((type_id = btf_field_iter_next(&it)))
2517 *type_id = ids[*type_id];
2518 }
2519
2520 free(ids);
2521 return btf_new;
2522
2523err_out:
2524 btf__free(btf_new);
2525 free(ids);
2526 errno = -err;
2527 return NULL;
2528}
2529
2530/* Create minimized BTF file for a set of BPF objects.
2531 *
2532 * The BTFGen algorithm is divided in two main parts: (1) collect the
2533 * BTF types that are involved in relocations and (2) generate the BTF
2534 * object using the collected types.
2535 *
2536 * In order to collect the types involved in the relocations, we parse
2537 * the BTF and BTF.ext sections of the BPF objects and use
2538 * bpf_core_calc_relo_insn() to get the target specification, this
2539 * indicates how the types and fields are used in a relocation.
2540 *
2541 * Types are recorded in different ways according to the kind of the
2542 * relocation. For field-based relocations only the members that are
2543 * actually used are saved in order to reduce the size of the generated
2544 * BTF file. For type-based relocations empty struct / unions are
2545 * generated and for enum-based relocations the whole type is saved.
2546 *
2547 * The second part of the algorithm generates the BTF object. It creates
2548 * an empty BTF object and fills it with the types recorded in the
2549 * previous step. This function takes care of only adding the structure
2550 * and union members that were marked as used and it also fixes up the
2551 * type IDs on the generated BTF object.
2552 */
2553static int minimize_btf(const char *src_btf, const char *dst_btf, const char *objspaths[])
2554{
2555 struct btfgen_info *info;
2556 struct btf *btf_new = NULL;
2557 int err, i;
2558
2559 info = btfgen_new_info(src_btf);
2560 if (!info) {
2561 err = -errno;
2562 p_err("failed to allocate info structure: %s", strerror(errno));
2563 goto out;
2564 }
2565
2566 for (i = 0; objspaths[i] != NULL; i++) {
2567 err = btfgen_record_obj(info, objspaths[i]);
2568 if (err) {
2569 p_err("error recording relocations for %s: %s", objspaths[i],
2570 strerror(errno));
2571 goto out;
2572 }
2573 }
2574
2575 btf_new = btfgen_get_btf(info);
2576 if (!btf_new) {
2577 err = -errno;
2578 p_err("error generating BTF: %s", strerror(errno));
2579 goto out;
2580 }
2581
2582 err = btf_save_raw(btf_new, dst_btf);
2583 if (err) {
2584 p_err("error saving btf file: %s", strerror(errno));
2585 goto out;
2586 }
2587
2588out:
2589 btf__free(btf_new);
2590 btfgen_free_info(info);
2591
2592 return err;
2593}
2594
2595static int do_min_core_btf(int argc, char **argv)
2596{
2597 const char *input, *output, **objs;
2598 int i, err;
2599
2600 if (!REQ_ARGS(3)) {
2601 usage();
2602 return -1;
2603 }
2604
2605 input = GET_ARG();
2606 output = GET_ARG();
2607
2608 objs = (const char **) calloc(argc + 1, sizeof(*objs));
2609 if (!objs) {
2610 p_err("failed to allocate array for object names");
2611 return -ENOMEM;
2612 }
2613
2614 i = 0;
2615 while (argc)
2616 objs[i++] = GET_ARG();
2617
2618 err = minimize_btf(input, output, objs);
2619 free(objs);
2620 return err;
2621}
2622
2623static const struct cmd cmds[] = {
2624 { "object", do_object },
2625 { "skeleton", do_skeleton },
2626 { "subskeleton", do_subskeleton },
2627 { "min_core_btf", do_min_core_btf},
2628 { "help", do_help },
2629 { 0 }
2630};
2631
2632int do_gen(int argc, char **argv)
2633{
2634 return cmd_select(cmds, argc, argv, do_help);
2635}