mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
621 lines
14 KiB
621 lines
14 KiB
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) |
|
/* Copyright (C) 2019 Facebook */ |
|
|
|
#ifndef _GNU_SOURCE |
|
#define _GNU_SOURCE |
|
#endif |
|
#include <ctype.h> |
|
#include <errno.h> |
|
#include <fcntl.h> |
|
#include <linux/err.h> |
|
#include <stdbool.h> |
|
#include <stdio.h> |
|
#include <string.h> |
|
#include <unistd.h> |
|
#include <bpf/bpf.h> |
|
#include <bpf/libbpf.h> |
|
#include <sys/types.h> |
|
#include <sys/stat.h> |
|
#include <sys/mman.h> |
|
#include <bpf/btf.h> |
|
|
|
#include "json_writer.h" |
|
#include "main.h" |
|
|
|
#define MAX_OBJ_NAME_LEN 64 |
|
|
|
static void sanitize_identifier(char *name) |
|
{ |
|
int i; |
|
|
|
for (i = 0; name[i]; i++) |
|
if (!isalnum(name[i]) && name[i] != '_') |
|
name[i] = '_'; |
|
} |
|
|
|
static bool str_has_suffix(const char *str, const char *suffix) |
|
{ |
|
size_t i, n1 = strlen(str), n2 = strlen(suffix); |
|
|
|
if (n1 < n2) |
|
return false; |
|
|
|
for (i = 0; i < n2; i++) { |
|
if (str[n1 - i - 1] != suffix[n2 - i - 1]) |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
static void get_obj_name(char *name, const char *file) |
|
{ |
|
/* Using basename() GNU version which doesn't modify arg. */ |
|
strncpy(name, basename(file), MAX_OBJ_NAME_LEN - 1); |
|
name[MAX_OBJ_NAME_LEN - 1] = '\0'; |
|
if (str_has_suffix(name, ".o")) |
|
name[strlen(name) - 2] = '\0'; |
|
sanitize_identifier(name); |
|
} |
|
|
|
static void get_header_guard(char *guard, const char *obj_name) |
|
{ |
|
int i; |
|
|
|
sprintf(guard, "__%s_SKEL_H__", obj_name); |
|
for (i = 0; guard[i]; i++) |
|
guard[i] = toupper(guard[i]); |
|
} |
|
|
|
static const char *get_map_ident(const struct bpf_map *map) |
|
{ |
|
const char *name = bpf_map__name(map); |
|
|
|
if (!bpf_map__is_internal(map)) |
|
return name; |
|
|
|
if (str_has_suffix(name, ".data")) |
|
return "data"; |
|
else if (str_has_suffix(name, ".rodata")) |
|
return "rodata"; |
|
else if (str_has_suffix(name, ".bss")) |
|
return "bss"; |
|
else if (str_has_suffix(name, ".kconfig")) |
|
return "kconfig"; |
|
else |
|
return NULL; |
|
} |
|
|
|
static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args) |
|
{ |
|
vprintf(fmt, args); |
|
} |
|
|
|
static int codegen_datasec_def(struct bpf_object *obj, |
|
struct btf *btf, |
|
struct btf_dump *d, |
|
const struct btf_type *sec, |
|
const char *obj_name) |
|
{ |
|
const char *sec_name = btf__name_by_offset(btf, sec->name_off); |
|
const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec); |
|
int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec); |
|
const char *sec_ident; |
|
char var_ident[256]; |
|
bool strip_mods = false; |
|
|
|
if (strcmp(sec_name, ".data") == 0) { |
|
sec_ident = "data"; |
|
} else if (strcmp(sec_name, ".bss") == 0) { |
|
sec_ident = "bss"; |
|
} else if (strcmp(sec_name, ".rodata") == 0) { |
|
sec_ident = "rodata"; |
|
strip_mods = true; |
|
} else if (strcmp(sec_name, ".kconfig") == 0) { |
|
sec_ident = "kconfig"; |
|
} else { |
|
return 0; |
|
} |
|
|
|
printf(" struct %s__%s {\n", obj_name, sec_ident); |
|
for (i = 0; i < vlen; i++, sec_var++) { |
|
const struct btf_type *var = btf__type_by_id(btf, sec_var->type); |
|
const char *var_name = btf__name_by_offset(btf, var->name_off); |
|
DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts, |
|
.field_name = var_ident, |
|
.indent_level = 2, |
|
.strip_mods = strip_mods, |
|
); |
|
int need_off = sec_var->offset, align_off, align; |
|
__u32 var_type_id = var->type; |
|
|
|
if (off > need_off) { |
|
p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n", |
|
sec_name, i, need_off, off); |
|
return -EINVAL; |
|
} |
|
|
|
align = btf__align_of(btf, var->type); |
|
if (align <= 0) { |
|
p_err("Failed to determine alignment of variable '%s': %d", |
|
var_name, align); |
|
return -EINVAL; |
|
} |
|
/* Assume 32-bit architectures when generating data section |
|
* struct memory layout. Given bpftool can't know which target |
|
* host architecture it's emitting skeleton for, we need to be |
|
* conservative and assume 32-bit one to ensure enough padding |
|
* bytes are generated for pointer and long types. This will |
|
* still work correctly for 64-bit architectures, because in |
|
* the worst case we'll generate unnecessary padding field, |
|
* which on 64-bit architectures is not strictly necessary and |
|
* would be handled by natural 8-byte alignment. But it still |
|
* will be a correct memory layout, based on recorded offsets |
|
* in BTF. |
|
*/ |
|
if (align > 4) |
|
align = 4; |
|
|
|
align_off = (off + align - 1) / align * align; |
|
if (align_off != need_off) { |
|
printf("\t\tchar __pad%d[%d];\n", |
|
pad_cnt, need_off - off); |
|
pad_cnt++; |
|
} |
|
|
|
/* sanitize variable name, e.g., for static vars inside |
|
* a function, it's name is '<function name>.<variable name>', |
|
* which we'll turn into a '<function name>_<variable name>' |
|
*/ |
|
var_ident[0] = '\0'; |
|
strncat(var_ident, var_name, sizeof(var_ident) - 1); |
|
sanitize_identifier(var_ident); |
|
|
|
printf("\t\t"); |
|
err = btf_dump__emit_type_decl(d, var_type_id, &opts); |
|
if (err) |
|
return err; |
|
printf(";\n"); |
|
|
|
off = sec_var->offset + sec_var->size; |
|
} |
|
printf(" } *%s;\n", sec_ident); |
|
return 0; |
|
} |
|
|
|
static int codegen_datasecs(struct bpf_object *obj, const char *obj_name) |
|
{ |
|
struct btf *btf = bpf_object__btf(obj); |
|
int n = btf__get_nr_types(btf); |
|
struct btf_dump *d; |
|
int i, err = 0; |
|
|
|
d = btf_dump__new(btf, NULL, NULL, codegen_btf_dump_printf); |
|
if (IS_ERR(d)) |
|
return PTR_ERR(d); |
|
|
|
for (i = 1; i <= n; i++) { |
|
const struct btf_type *t = btf__type_by_id(btf, i); |
|
|
|
if (!btf_is_datasec(t)) |
|
continue; |
|
|
|
err = codegen_datasec_def(obj, btf, d, t, obj_name); |
|
if (err) |
|
goto out; |
|
} |
|
out: |
|
btf_dump__free(d); |
|
return err; |
|
} |
|
|
|
static void codegen(const char *template, ...) |
|
{ |
|
const char *src, *end; |
|
int skip_tabs = 0, n; |
|
char *s, *dst; |
|
va_list args; |
|
char c; |
|
|
|
n = strlen(template); |
|
s = malloc(n + 1); |
|
if (!s) |
|
exit(-1); |
|
src = template; |
|
dst = s; |
|
|
|
/* find out "baseline" indentation to skip */ |
|
while ((c = *src++)) { |
|
if (c == '\t') { |
|
skip_tabs++; |
|
} else if (c == '\n') { |
|
break; |
|
} else { |
|
p_err("unrecognized character at pos %td in template '%s'", |
|
src - template - 1, template); |
|
free(s); |
|
exit(-1); |
|
} |
|
} |
|
|
|
while (*src) { |
|
/* skip baseline indentation tabs */ |
|
for (n = skip_tabs; n > 0; n--, src++) { |
|
if (*src != '\t') { |
|
p_err("not enough tabs at pos %td in template '%s'", |
|
src - template - 1, template); |
|
free(s); |
|
exit(-1); |
|
} |
|
} |
|
/* trim trailing whitespace */ |
|
end = strchrnul(src, '\n'); |
|
for (n = end - src; n > 0 && isspace(src[n - 1]); n--) |
|
; |
|
memcpy(dst, src, n); |
|
dst += n; |
|
if (*end) |
|
*dst++ = '\n'; |
|
src = *end ? end + 1 : end; |
|
} |
|
*dst++ = '\0'; |
|
|
|
/* print out using adjusted template */ |
|
va_start(args, template); |
|
n = vprintf(s, args); |
|
va_end(args); |
|
|
|
free(s); |
|
} |
|
|
|
static int do_skeleton(int argc, char **argv) |
|
{ |
|
char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")]; |
|
size_t i, map_cnt = 0, prog_cnt = 0, file_sz, mmap_sz; |
|
DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts); |
|
char obj_name[MAX_OBJ_NAME_LEN], *obj_data; |
|
struct bpf_object *obj = NULL; |
|
const char *file, *ident; |
|
struct bpf_program *prog; |
|
int fd, len, err = -1; |
|
struct bpf_map *map; |
|
struct btf *btf; |
|
struct stat st; |
|
|
|
if (!REQ_ARGS(1)) { |
|
usage(); |
|
return -1; |
|
} |
|
file = GET_ARG(); |
|
|
|
if (argc) { |
|
p_err("extra unknown arguments"); |
|
return -1; |
|
} |
|
|
|
if (stat(file, &st)) { |
|
p_err("failed to stat() %s: %s", file, strerror(errno)); |
|
return -1; |
|
} |
|
file_sz = st.st_size; |
|
mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE)); |
|
fd = open(file, O_RDONLY); |
|
if (fd < 0) { |
|
p_err("failed to open() %s: %s", file, strerror(errno)); |
|
return -1; |
|
} |
|
obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0); |
|
if (obj_data == MAP_FAILED) { |
|
obj_data = NULL; |
|
p_err("failed to mmap() %s: %s", file, strerror(errno)); |
|
goto out; |
|
} |
|
get_obj_name(obj_name, file); |
|
opts.object_name = obj_name; |
|
obj = bpf_object__open_mem(obj_data, file_sz, &opts); |
|
if (IS_ERR(obj)) { |
|
char err_buf[256]; |
|
|
|
libbpf_strerror(PTR_ERR(obj), err_buf, sizeof(err_buf)); |
|
p_err("failed to open BPF object file: %s", err_buf); |
|
obj = NULL; |
|
goto out; |
|
} |
|
|
|
bpf_object__for_each_map(map, obj) { |
|
ident = get_map_ident(map); |
|
if (!ident) { |
|
p_err("ignoring unrecognized internal map '%s'...", |
|
bpf_map__name(map)); |
|
continue; |
|
} |
|
map_cnt++; |
|
} |
|
bpf_object__for_each_program(prog, obj) { |
|
prog_cnt++; |
|
} |
|
|
|
get_header_guard(header_guard, obj_name); |
|
codegen("\ |
|
\n\ |
|
/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\ |
|
\n\ |
|
/* THIS FILE IS AUTOGENERATED! */ \n\ |
|
#ifndef %2$s \n\ |
|
#define %2$s \n\ |
|
\n\ |
|
#include <stdlib.h> \n\ |
|
#include <bpf/libbpf.h> \n\ |
|
\n\ |
|
struct %1$s { \n\ |
|
struct bpf_object_skeleton *skeleton; \n\ |
|
struct bpf_object *obj; \n\ |
|
", |
|
obj_name, header_guard |
|
); |
|
|
|
if (map_cnt) { |
|
printf("\tstruct {\n"); |
|
bpf_object__for_each_map(map, obj) { |
|
ident = get_map_ident(map); |
|
if (!ident) |
|
continue; |
|
printf("\t\tstruct bpf_map *%s;\n", ident); |
|
} |
|
printf("\t} maps;\n"); |
|
} |
|
|
|
if (prog_cnt) { |
|
printf("\tstruct {\n"); |
|
bpf_object__for_each_program(prog, obj) { |
|
printf("\t\tstruct bpf_program *%s;\n", |
|
bpf_program__name(prog)); |
|
} |
|
printf("\t} progs;\n"); |
|
printf("\tstruct {\n"); |
|
bpf_object__for_each_program(prog, obj) { |
|
printf("\t\tstruct bpf_link *%s;\n", |
|
bpf_program__name(prog)); |
|
} |
|
printf("\t} links;\n"); |
|
} |
|
|
|
btf = bpf_object__btf(obj); |
|
if (btf) { |
|
err = codegen_datasecs(obj, obj_name); |
|
if (err) |
|
goto out; |
|
} |
|
|
|
codegen("\ |
|
\n\ |
|
}; \n\ |
|
\n\ |
|
static void \n\ |
|
%1$s__destroy(struct %1$s *obj) \n\ |
|
{ \n\ |
|
if (!obj) \n\ |
|
return; \n\ |
|
if (obj->skeleton) \n\ |
|
bpf_object__destroy_skeleton(obj->skeleton);\n\ |
|
free(obj); \n\ |
|
} \n\ |
|
\n\ |
|
static inline int \n\ |
|
%1$s__create_skeleton(struct %1$s *obj); \n\ |
|
\n\ |
|
static inline struct %1$s * \n\ |
|
%1$s__open_opts(const struct bpf_object_open_opts *opts) \n\ |
|
{ \n\ |
|
struct %1$s *obj; \n\ |
|
\n\ |
|
obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\ |
|
if (!obj) \n\ |
|
return NULL; \n\ |
|
if (%1$s__create_skeleton(obj)) \n\ |
|
goto err; \n\ |
|
if (bpf_object__open_skeleton(obj->skeleton, opts)) \n\ |
|
goto err; \n\ |
|
\n\ |
|
return obj; \n\ |
|
err: \n\ |
|
%1$s__destroy(obj); \n\ |
|
return NULL; \n\ |
|
} \n\ |
|
\n\ |
|
static inline struct %1$s * \n\ |
|
%1$s__open(void) \n\ |
|
{ \n\ |
|
return %1$s__open_opts(NULL); \n\ |
|
} \n\ |
|
\n\ |
|
static inline int \n\ |
|
%1$s__load(struct %1$s *obj) \n\ |
|
{ \n\ |
|
return bpf_object__load_skeleton(obj->skeleton); \n\ |
|
} \n\ |
|
\n\ |
|
static inline struct %1$s * \n\ |
|
%1$s__open_and_load(void) \n\ |
|
{ \n\ |
|
struct %1$s *obj; \n\ |
|
\n\ |
|
obj = %1$s__open(); \n\ |
|
if (!obj) \n\ |
|
return NULL; \n\ |
|
if (%1$s__load(obj)) { \n\ |
|
%1$s__destroy(obj); \n\ |
|
return NULL; \n\ |
|
} \n\ |
|
return obj; \n\ |
|
} \n\ |
|
\n\ |
|
static inline int \n\ |
|
%1$s__attach(struct %1$s *obj) \n\ |
|
{ \n\ |
|
return bpf_object__attach_skeleton(obj->skeleton); \n\ |
|
} \n\ |
|
\n\ |
|
static inline void \n\ |
|
%1$s__detach(struct %1$s *obj) \n\ |
|
{ \n\ |
|
return bpf_object__detach_skeleton(obj->skeleton); \n\ |
|
} \n\ |
|
", |
|
obj_name |
|
); |
|
|
|
codegen("\ |
|
\n\ |
|
\n\ |
|
static inline int \n\ |
|
%1$s__create_skeleton(struct %1$s *obj) \n\ |
|
{ \n\ |
|
struct bpf_object_skeleton *s; \n\ |
|
\n\ |
|
s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\ |
|
if (!s) \n\ |
|
return -1; \n\ |
|
obj->skeleton = s; \n\ |
|
\n\ |
|
s->sz = sizeof(*s); \n\ |
|
s->name = \"%1$s\"; \n\ |
|
s->obj = &obj->obj; \n\ |
|
", |
|
obj_name |
|
); |
|
if (map_cnt) { |
|
codegen("\ |
|
\n\ |
|
\n\ |
|
/* maps */ \n\ |
|
s->map_cnt = %zu; \n\ |
|
s->map_skel_sz = sizeof(*s->maps); \n\ |
|
s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz);\n\ |
|
if (!s->maps) \n\ |
|
goto err; \n\ |
|
", |
|
map_cnt |
|
); |
|
i = 0; |
|
bpf_object__for_each_map(map, obj) { |
|
ident = get_map_ident(map); |
|
|
|
if (!ident) |
|
continue; |
|
|
|
codegen("\ |
|
\n\ |
|
\n\ |
|
s->maps[%zu].name = \"%s\"; \n\ |
|
s->maps[%zu].map = &obj->maps.%s; \n\ |
|
", |
|
i, bpf_map__name(map), i, ident); |
|
/* memory-mapped internal maps */ |
|
if (bpf_map__is_internal(map) && |
|
(bpf_map__def(map)->map_flags & BPF_F_MMAPABLE)) { |
|
printf("\ts->maps[%zu].mmaped = (void **)&obj->%s;\n", |
|
i, ident); |
|
} |
|
i++; |
|
} |
|
} |
|
if (prog_cnt) { |
|
codegen("\ |
|
\n\ |
|
\n\ |
|
/* programs */ \n\ |
|
s->prog_cnt = %zu; \n\ |
|
s->prog_skel_sz = sizeof(*s->progs); \n\ |
|
s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\ |
|
if (!s->progs) \n\ |
|
goto err; \n\ |
|
", |
|
prog_cnt |
|
); |
|
i = 0; |
|
bpf_object__for_each_program(prog, obj) { |
|
codegen("\ |
|
\n\ |
|
\n\ |
|
s->progs[%1$zu].name = \"%2$s\"; \n\ |
|
s->progs[%1$zu].prog = &obj->progs.%2$s;\n\ |
|
s->progs[%1$zu].link = &obj->links.%2$s;\n\ |
|
", |
|
i, bpf_program__name(prog)); |
|
i++; |
|
} |
|
} |
|
codegen("\ |
|
\n\ |
|
\n\ |
|
s->data_sz = %d; \n\ |
|
s->data = (void *)\"\\ \n\ |
|
", |
|
file_sz); |
|
|
|
/* embed contents of BPF object file */ |
|
for (i = 0, len = 0; i < file_sz; i++) { |
|
int w = obj_data[i] ? 4 : 2; |
|
|
|
len += w; |
|
if (len > 78) { |
|
printf("\\\n"); |
|
len = w; |
|
} |
|
if (!obj_data[i]) |
|
printf("\\0"); |
|
else |
|
printf("\\x%02x", (unsigned char)obj_data[i]); |
|
} |
|
|
|
codegen("\ |
|
\n\ |
|
\"; \n\ |
|
\n\ |
|
return 0; \n\ |
|
err: \n\ |
|
bpf_object__destroy_skeleton(s); \n\ |
|
return -1; \n\ |
|
} \n\ |
|
\n\ |
|
#endif /* %s */ \n\ |
|
", |
|
header_guard); |
|
err = 0; |
|
out: |
|
bpf_object__close(obj); |
|
if (obj_data) |
|
munmap(obj_data, mmap_sz); |
|
close(fd); |
|
return err; |
|
} |
|
|
|
static int do_help(int argc, char **argv) |
|
{ |
|
if (json_output) { |
|
jsonw_null(json_wtr); |
|
return 0; |
|
} |
|
|
|
fprintf(stderr, |
|
"Usage: %1$s %2$s skeleton FILE\n" |
|
" %1$s %2$s help\n" |
|
"\n" |
|
" " HELP_SPEC_OPTIONS "\n" |
|
"", |
|
bin_name, "gen"); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct cmd cmds[] = { |
|
{ "skeleton", do_skeleton }, |
|
{ "help", do_help }, |
|
{ 0 } |
|
}; |
|
|
|
int do_gen(int argc, char **argv) |
|
{ |
|
return cmd_select(cmds, argc, argv, do_help); |
|
}
|
|
|