1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2019 Facebook */
10 #include <linux/err.h>
16 #include <bpf/libbpf.h>
17 #include <sys/types.h>
22 #include "json_writer.h"
25 #define MAX_OBJ_NAME_LEN 64
27 static void sanitize_identifier(char *name)
31 for (i = 0; name[i]; i++)
32 if (!isalnum(name[i]) && name[i] != '_')
36 static bool str_has_suffix(const char *str, const char *suffix)
38 size_t i, n1 = strlen(str), n2 = strlen(suffix);
43 for (i = 0; i < n2; i++) {
44 if (str[n1 - i - 1] != suffix[n2 - i - 1])
51 static void get_obj_name(char *name, const char *file)
53 /* Using basename() GNU version which doesn't modify arg. */
54 strncpy(name, basename(file), MAX_OBJ_NAME_LEN - 1);
55 name[MAX_OBJ_NAME_LEN - 1] = '\0';
56 if (str_has_suffix(name, ".o"))
57 name[strlen(name) - 2] = '\0';
58 sanitize_identifier(name);
61 static void get_header_guard(char *guard, const char *obj_name)
65 sprintf(guard, "__%s_SKEL_H__", obj_name);
66 for (i = 0; guard[i]; i++)
67 guard[i] = toupper(guard[i]);
70 static const char *get_map_ident(const struct bpf_map *map)
72 const char *name = bpf_map__name(map);
74 if (!bpf_map__is_internal(map))
77 if (str_has_suffix(name, ".data"))
79 else if (str_has_suffix(name, ".rodata"))
81 else if (str_has_suffix(name, ".bss"))
83 else if (str_has_suffix(name, ".kconfig"))
89 static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args)
94 static int codegen_datasec_def(struct bpf_object *obj,
97 const struct btf_type *sec,
100 const char *sec_name = btf__name_by_offset(btf, sec->name_off);
101 const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec);
102 int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec);
103 const char *sec_ident;
105 bool strip_mods = false;
107 if (strcmp(sec_name, ".data") == 0) {
109 } else if (strcmp(sec_name, ".bss") == 0) {
111 } else if (strcmp(sec_name, ".rodata") == 0) {
112 sec_ident = "rodata";
114 } else if (strcmp(sec_name, ".kconfig") == 0) {
115 sec_ident = "kconfig";
120 printf(" struct %s__%s {\n", obj_name, sec_ident);
121 for (i = 0; i < vlen; i++, sec_var++) {
122 const struct btf_type *var = btf__type_by_id(btf, sec_var->type);
123 const char *var_name = btf__name_by_offset(btf, var->name_off);
124 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts,
125 .field_name = var_ident,
127 .strip_mods = strip_mods,
129 int need_off = sec_var->offset, align_off, align;
130 __u32 var_type_id = var->type;
132 if (off > need_off) {
133 p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n",
134 sec_name, i, need_off, off);
138 align = btf__align_of(btf, var->type);
140 p_err("Failed to determine alignment of variable '%s': %d",
144 /* Assume 32-bit architectures when generating data section
145 * struct memory layout. Given bpftool can't know which target
146 * host architecture it's emitting skeleton for, we need to be
147 * conservative and assume 32-bit one to ensure enough padding
148 * bytes are generated for pointer and long types. This will
149 * still work correctly for 64-bit architectures, because in
150 * the worst case we'll generate unnecessary padding field,
151 * which on 64-bit architectures is not strictly necessary and
152 * would be handled by natural 8-byte alignment. But it still
153 * will be a correct memory layout, based on recorded offsets
159 align_off = (off + align - 1) / align * align;
160 if (align_off != need_off) {
161 printf("\t\tchar __pad%d[%d];\n",
162 pad_cnt, need_off - off);
166 /* sanitize variable name, e.g., for static vars inside
167 * a function, it's name is '<function name>.<variable name>',
168 * which we'll turn into a '<function name>_<variable name>'
171 strncat(var_ident, var_name, sizeof(var_ident) - 1);
172 sanitize_identifier(var_ident);
175 err = btf_dump__emit_type_decl(d, var_type_id, &opts);
180 off = sec_var->offset + sec_var->size;
182 printf(" } *%s;\n", sec_ident);
186 static int codegen_datasecs(struct bpf_object *obj, const char *obj_name)
188 struct btf *btf = bpf_object__btf(obj);
189 int n = btf__get_nr_types(btf);
193 d = btf_dump__new(btf, NULL, NULL, codegen_btf_dump_printf);
197 for (i = 1; i <= n; i++) {
198 const struct btf_type *t = btf__type_by_id(btf, i);
200 if (!btf_is_datasec(t))
203 err = codegen_datasec_def(obj, btf, d, t, obj_name);
212 static void codegen(const char *template, ...)
214 const char *src, *end;
215 int skip_tabs = 0, n;
220 n = strlen(template);
227 /* find out "baseline" indentation to skip */
228 while ((c = *src++)) {
231 } else if (c == '\n') {
234 p_err("unrecognized character at pos %td in template '%s'",
235 src - template - 1, template);
242 /* skip baseline indentation tabs */
243 for (n = skip_tabs; n > 0; n--, src++) {
245 p_err("not enough tabs at pos %td in template '%s'",
246 src - template - 1, template);
251 /* trim trailing whitespace */
252 end = strchrnul(src, '\n');
253 for (n = end - src; n > 0 && isspace(src[n - 1]); n--)
259 src = *end ? end + 1 : end;
263 /* print out using adjusted template */
264 va_start(args, template);
265 n = vprintf(s, args);
271 static int do_skeleton(int argc, char **argv)
273 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")];
274 size_t i, map_cnt = 0, prog_cnt = 0, file_sz, mmap_sz;
275 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
276 char obj_name[MAX_OBJ_NAME_LEN] = "", *obj_data;
277 struct bpf_object *obj = NULL;
278 const char *file, *ident;
279 struct bpf_program *prog;
280 int fd, len, err = -1;
295 if (is_prefix(*argv, "name")) {
298 if (obj_name[0] != '\0') {
299 p_err("object name already specified");
303 strncpy(obj_name, *argv, MAX_OBJ_NAME_LEN - 1);
304 obj_name[MAX_OBJ_NAME_LEN - 1] = '\0';
306 p_err("unknown arg %s", *argv);
314 p_err("extra unknown arguments");
318 if (stat(file, &st)) {
319 p_err("failed to stat() %s: %s", file, strerror(errno));
322 file_sz = st.st_size;
323 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE));
324 fd = open(file, O_RDONLY);
326 p_err("failed to open() %s: %s", file, strerror(errno));
329 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0);
330 if (obj_data == MAP_FAILED) {
332 p_err("failed to mmap() %s: %s", file, strerror(errno));
335 if (obj_name[0] == '\0')
336 get_obj_name(obj_name, file);
337 opts.object_name = obj_name;
338 obj = bpf_object__open_mem(obj_data, file_sz, &opts);
342 libbpf_strerror(PTR_ERR(obj), err_buf, sizeof(err_buf));
343 p_err("failed to open BPF object file: %s", err_buf);
348 bpf_object__for_each_map(map, obj) {
349 ident = get_map_ident(map);
351 p_err("ignoring unrecognized internal map '%s'...",
357 bpf_object__for_each_program(prog, obj) {
361 get_header_guard(header_guard, obj_name);
364 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\
366 /* THIS FILE IS AUTOGENERATED! */ \n\
370 #include <stdlib.h> \n\
371 #include <bpf/libbpf.h> \n\
374 struct bpf_object_skeleton *skeleton; \n\
375 struct bpf_object *obj; \n\
377 obj_name, header_guard
381 printf("\tstruct {\n");
382 bpf_object__for_each_map(map, obj) {
383 ident = get_map_ident(map);
386 printf("\t\tstruct bpf_map *%s;\n", ident);
388 printf("\t} maps;\n");
392 printf("\tstruct {\n");
393 bpf_object__for_each_program(prog, obj) {
394 printf("\t\tstruct bpf_program *%s;\n",
395 bpf_program__name(prog));
397 printf("\t} progs;\n");
398 printf("\tstruct {\n");
399 bpf_object__for_each_program(prog, obj) {
400 printf("\t\tstruct bpf_link *%s;\n",
401 bpf_program__name(prog));
403 printf("\t} links;\n");
406 btf = bpf_object__btf(obj);
408 err = codegen_datasecs(obj, obj_name);
418 %1$s__destroy(struct %1$s *obj) \n\
422 if (obj->skeleton) \n\
423 bpf_object__destroy_skeleton(obj->skeleton);\n\
427 static inline int \n\
428 %1$s__create_skeleton(struct %1$s *obj); \n\
430 static inline struct %1$s * \n\
431 %1$s__open_opts(const struct bpf_object_open_opts *opts) \n\
433 struct %1$s *obj; \n\
435 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\
438 if (%1$s__create_skeleton(obj)) \n\
440 if (bpf_object__open_skeleton(obj->skeleton, opts)) \n\
445 %1$s__destroy(obj); \n\
449 static inline struct %1$s * \n\
452 return %1$s__open_opts(NULL); \n\
455 static inline int \n\
456 %1$s__load(struct %1$s *obj) \n\
458 return bpf_object__load_skeleton(obj->skeleton); \n\
461 static inline struct %1$s * \n\
462 %1$s__open_and_load(void) \n\
464 struct %1$s *obj; \n\
466 obj = %1$s__open(); \n\
469 if (%1$s__load(obj)) { \n\
470 %1$s__destroy(obj); \n\
476 static inline int \n\
477 %1$s__attach(struct %1$s *obj) \n\
479 return bpf_object__attach_skeleton(obj->skeleton); \n\
482 static inline void \n\
483 %1$s__detach(struct %1$s *obj) \n\
485 return bpf_object__detach_skeleton(obj->skeleton); \n\
494 static inline int \n\
495 %1$s__create_skeleton(struct %1$s *obj) \n\
497 struct bpf_object_skeleton *s; \n\
499 s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\
502 obj->skeleton = s; \n\
504 s->sz = sizeof(*s); \n\
505 s->name = \"%1$s\"; \n\
506 s->obj = &obj->obj; \n\
515 s->map_cnt = %zu; \n\
516 s->map_skel_sz = sizeof(*s->maps); \n\
517 s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz);\n\
524 bpf_object__for_each_map(map, obj) {
525 ident = get_map_ident(map);
533 s->maps[%zu].name = \"%s\"; \n\
534 s->maps[%zu].map = &obj->maps.%s; \n\
536 i, bpf_map__name(map), i, ident);
537 /* memory-mapped internal maps */
538 if (bpf_map__is_internal(map) &&
539 (bpf_map__def(map)->map_flags & BPF_F_MMAPABLE)) {
540 printf("\ts->maps[%zu].mmaped = (void **)&obj->%s;\n",
551 s->prog_cnt = %zu; \n\
552 s->prog_skel_sz = sizeof(*s->progs); \n\
553 s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\
560 bpf_object__for_each_program(prog, obj) {
564 s->progs[%1$zu].name = \"%2$s\"; \n\
565 s->progs[%1$zu].prog = &obj->progs.%2$s;\n\
566 s->progs[%1$zu].link = &obj->links.%2$s;\n\
568 i, bpf_program__name(prog));
576 s->data = (void *)\"\\ \n\
580 /* embed contents of BPF object file */
581 for (i = 0, len = 0; i < file_sz; i++) {
582 int w = obj_data[i] ? 4 : 2;
592 printf("\\x%02x", (unsigned char)obj_data[i]);
601 bpf_object__destroy_skeleton(s); \n\
610 bpf_object__close(obj);
612 munmap(obj_data, mmap_sz);
617 static int do_object(int argc, char **argv)
619 struct bpf_linker *linker;
620 const char *output_file, *file;
628 output_file = GET_ARG();
630 linker = bpf_linker__new(output_file, NULL);
632 p_err("failed to create BPF linker instance");
639 err = bpf_linker__add_file(linker, file);
641 p_err("failed to link '%s': %s (%d)", file, strerror(err), err);
646 err = bpf_linker__finalize(linker);
648 p_err("failed to finalize ELF file: %s (%d)", strerror(err), err);
654 bpf_linker__free(linker);
658 static int do_help(int argc, char **argv)
661 jsonw_null(json_wtr);
666 "Usage: %1$s %2$s object OUTPUT_FILE INPUT_FILE [INPUT_FILE...]\n"
667 " %1$s %2$s skeleton FILE [name OBJECT_NAME]\n"
670 " " HELP_SPEC_OPTIONS "\n"
677 static const struct cmd cmds[] = {
678 { "object", do_object },
679 { "skeleton", do_skeleton },
684 int do_gen(int argc, char **argv)
686 return cmd_select(cmds, argc, argv, do_help);