microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

libbpf: Normalize and improve logging across few functions 

Make libbpf logs follow similar pattern and provide more context like section
name or program name, where appropriate. Also, add BPF_INSN_SZ constant and
use it throughout to clean up code a little bit. This commit doesn't have any
functional changes and just removes some code changes out of the way before
bigger refactoring in libbpf internals.

Signed-off-by: Andrii Nakryiko <andriin@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200820231250.1293069-6-andriin@fb.com
This commit is contained in:
Andrii Nakryiko 2020-08-20 16:12:39 -07:00 коммит произвёл Alexei Starovoitov
Родитель 50e09460d9
Коммит 9c0f8cbdc0
1 изменённых файлов: 67 добавлений и 50 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

117
tools/lib/bpf/libbpf.c
Просмотреть файл

@ -63,6 +63,8 @@
#define BPF_FS_MAGIC 0xcafe4a11 #define BPF_FS_MAGIC 0xcafe4a11
#endif #endif
#define BPF_INSN_SZ (sizeof(struct bpf_insn))
/* vsprintf() in __base_pr() uses nonliteral format string. It may break /* vsprintf() in __base_pr() uses nonliteral format string. It may break
* compilation if user enables corresponding warning. Disable it explicitly. * compilation if user enables corresponding warning. Disable it explicitly.
*/ */
@ -3225,7 +3227,7 @@ bpf_object__section_to_libbpf_map_type(const struct bpf_object *obj, int shndx)
static int bpf_program__record_reloc(struct bpf_program *prog, static int bpf_program__record_reloc(struct bpf_program *prog,
struct reloc_desc *reloc_desc, struct reloc_desc *reloc_desc,
__u32 insn_idx, const char *name, __u32 insn_idx, const char *sym_name,
const GElf_Sym *sym, const GElf_Rel *rel) const GElf_Sym *sym, const GElf_Rel *rel)
{ {
struct bpf_insn *insn = &prog->insns[insn_idx]; struct bpf_insn *insn = &prog->insns[insn_idx];
@ -3233,22 +3235,25 @@ static int bpf_program__record_reloc(struct bpf_program *prog,
struct bpf_object *obj = prog->obj; struct bpf_object *obj = prog->obj;
__u32 shdr_idx = sym->st_shndx; __u32 shdr_idx = sym->st_shndx;
enum libbpf_map_type type; enum libbpf_map_type type;
const char *sym_sec_name;
struct bpf_map *map; struct bpf_map *map;
/* sub-program call relocation */ /* sub-program call relocation */
if (insn->code == (BPF_JMP | BPF_CALL)) { if (insn->code == (BPF_JMP | BPF_CALL)) {
if (insn->src_reg != BPF_PSEUDO_CALL) { if (insn->src_reg != BPF_PSEUDO_CALL) {
pr_warn("incorrect bpf_call opcode\n"); pr_warn("prog '%s': incorrect bpf_call opcode\n", prog->name);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
/* text_shndx can be 0, if no default "main" program exists */ /* text_shndx can be 0, if no default "main" program exists */
if (!shdr_idx || shdr_idx != obj->efile.text_shndx) { if (!shdr_idx || shdr_idx != obj->efile.text_shndx) {
pr_warn("bad call relo against section %u\n", shdr_idx); sym_sec_name = elf_sec_name(obj, elf_sec_by_idx(obj, shdr_idx));
pr_warn("prog '%s': bad call relo against '%s' in section '%s'\n",
prog->name, sym_name, sym_sec_name);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
if (sym->st_value % 8) { if (sym->st_value % BPF_INSN_SZ) {
pr_warn("bad call relo offset: %zu\n", pr_warn("prog '%s': bad call relo against '%s' at offset %zu\n",
(size_t)sym->st_value); prog->name, sym_name, (size_t)sym->st_value);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
reloc_desc->type = RELO_CALL; reloc_desc->type = RELO_CALL;
@ -3259,8 +3264,8 @@ static int bpf_program__record_reloc(struct bpf_program *prog,
} }
if (insn->code != (BPF_LD | BPF_IMM | BPF_DW)) { if (insn->code != (BPF_LD | BPF_IMM | BPF_DW)) {
pr_warn("invalid relo for insns[%d].code 0x%x\n", pr_warn("prog '%s': invalid relo against '%s' for insns[%d].code 0x%x\n",
insn_idx, insn->code); prog->name, sym_name, insn_idx, insn->code);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
@ -3275,12 +3280,12 @@ static int bpf_program__record_reloc(struct bpf_program *prog,
break; break;
} }
if (i >= n) { if (i >= n) {
pr_warn("extern relo failed to find extern for sym %d\n", pr_warn("prog '%s': extern relo failed to find extern for '%s' (%d)\n",
sym_idx); prog->name, sym_name, sym_idx);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
pr_debug("found extern #%d '%s' (sym %d) for insn %u\n", pr_debug("prog '%s': found extern #%d '%s' (sym %d) for insn #%u\n",
i, ext->name, ext->sym_idx, insn_idx); prog->name, i, ext->name, ext->sym_idx, insn_idx);
reloc_desc->type = RELO_EXTERN; reloc_desc->type = RELO_EXTERN;
reloc_desc->insn_idx = insn_idx; reloc_desc->insn_idx = insn_idx;
reloc_desc->sym_off = i; /* sym_off stores extern index */ reloc_desc->sym_off = i; /* sym_off stores extern index */
@ -3288,18 +3293,19 @@ static int bpf_program__record_reloc(struct bpf_program *prog,
} }
if (!shdr_idx || shdr_idx >= SHN_LORESERVE) { if (!shdr_idx || shdr_idx >= SHN_LORESERVE) {
pr_warn("invalid relo for \'%s\' in special section 0x%x; forgot to initialize global var?..\n", pr_warn("prog '%s': invalid relo against '%s' in special section 0x%x; forgot to initialize global var?..\n",
name, shdr_idx); prog->name, sym_name, shdr_idx);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
type = bpf_object__section_to_libbpf_map_type(obj, shdr_idx); type = bpf_object__section_to_libbpf_map_type(obj, shdr_idx);
sym_sec_name = elf_sec_name(obj, elf_sec_by_idx(obj, shdr_idx));
/* generic map reference relocation */ /* generic map reference relocation */
if (type == LIBBPF_MAP_UNSPEC) { if (type == LIBBPF_MAP_UNSPEC) {
if (!bpf_object__shndx_is_maps(obj, shdr_idx)) { if (!bpf_object__shndx_is_maps(obj, shdr_idx)) {
pr_warn("bad map relo against section %u\n", pr_warn("prog '%s': bad map relo against '%s' in section '%s'\n",
shdr_idx); prog->name, sym_name, sym_sec_name);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
for (map_idx = 0; map_idx < nr_maps; map_idx++) { for (map_idx = 0; map_idx < nr_maps; map_idx++) {
@ -3308,14 +3314,14 @@ static int bpf_program__record_reloc(struct bpf_program *prog,
map->sec_idx != sym->st_shndx || map->sec_idx != sym->st_shndx ||
map->sec_offset != sym->st_value) map->sec_offset != sym->st_value)
continue; continue;
pr_debug("found map %zd (%s, sec %d, off %zu) for insn %u\n", pr_debug("prog '%s': found map %zd (%s, sec %d, off %zu) for insn #%u\n",
map_idx, map->name, map->sec_idx, prog->name, map_idx, map->name, map->sec_idx,
map->sec_offset, insn_idx); map->sec_offset, insn_idx);
break; break;
} }
if (map_idx >= nr_maps) { if (map_idx >= nr_maps) {
pr_warn("map relo failed to find map for sec %u, off %zu\n", pr_warn("prog '%s': map relo failed to find map for section '%s', off %zu\n",
shdr_idx, (size_t)sym->st_value); prog->name, sym_sec_name, (size_t)sym->st_value);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
reloc_desc->type = RELO_LD64; reloc_desc->type = RELO_LD64;
@ -3327,21 +3333,22 @@ static int bpf_program__record_reloc(struct bpf_program *prog,
/* global data map relocation */ /* global data map relocation */
if (!bpf_object__shndx_is_data(obj, shdr_idx)) { if (!bpf_object__shndx_is_data(obj, shdr_idx)) {
pr_warn("bad data relo against section %u\n", shdr_idx); pr_warn("prog '%s': bad data relo against section '%s'\n",
prog->name, sym_sec_name);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
for (map_idx = 0; map_idx < nr_maps; map_idx++) { for (map_idx = 0; map_idx < nr_maps; map_idx++) {
map = &obj->maps[map_idx]; map = &obj->maps[map_idx];
if (map->libbpf_type != type) if (map->libbpf_type != type)
continue; continue;
pr_debug("found data map %zd (%s, sec %d, off %zu) for insn %u\n", pr_debug("prog '%s': found data map %zd (%s, sec %d, off %zu) for insn %u\n",
map_idx, map->name, map->sec_idx, map->sec_offset, prog->name, map_idx, map->name, map->sec_idx,
insn_idx); map->sec_offset, insn_idx);
break; break;
} }
if (map_idx >= nr_maps) { if (map_idx >= nr_maps) {
pr_warn("data relo failed to find map for sec %u\n", pr_warn("prog '%s': data relo failed to find map for section '%s'\n",
shdr_idx); prog->name, sym_sec_name);
return -LIBBPF_ERRNO__RELOC; return -LIBBPF_ERRNO__RELOC;
} }
@ -3357,9 +3364,17 @@ bpf_program__collect_reloc(struct bpf_program *prog, GElf_Shdr *shdr,
Elf_Data *data, struct bpf_object *obj) Elf_Data *data, struct bpf_object *obj)
{ {
Elf_Data *symbols = obj->efile.symbols; Elf_Data *symbols = obj->efile.symbols;
const char *relo_sec_name, *sec_name;
size_t sec_idx = shdr->sh_info;
int err, i, nrels; int err, i, nrels;
pr_debug("collecting relocating info for: '%s'\n", prog->section_name); relo_sec_name = elf_sec_str(obj, shdr->sh_name);
sec_name = elf_sec_name(obj, elf_sec_by_idx(obj, sec_idx));
if (!relo_sec_name || !sec_name)
return -EINVAL;
pr_debug("sec '%s': collecting relocation for section(%zu) '%s'\n",
relo_sec_name, sec_idx, sec_name);
nrels = shdr->sh_size / shdr->sh_entsize; nrels = shdr->sh_size / shdr->sh_entsize;
prog->reloc_desc = malloc(sizeof(*prog->reloc_desc) * nrels); prog->reloc_desc = malloc(sizeof(*prog->reloc_desc) * nrels);
@ -3370,34 +3385,34 @@ bpf_program__collect_reloc(struct bpf_program *prog, GElf_Shdr *shdr,
prog->nr_reloc = nrels; prog->nr_reloc = nrels;
for (i = 0; i < nrels; i++) { for (i = 0; i < nrels; i++) {
const char *name; const char *sym_name;
__u32 insn_idx; __u32 insn_idx;
GElf_Sym sym; GElf_Sym sym;
GElf_Rel rel; GElf_Rel rel;
if (!gelf_getrel(data, i, &rel)) { if (!gelf_getrel(data, i, &rel)) {
pr_warn("relocation: failed to get %d reloc\n", i); pr_warn("sec '%s': failed to get relo #%d\n", relo_sec_name, i);
return -LIBBPF_ERRNO__FORMAT; return -LIBBPF_ERRNO__FORMAT;
} }
if (!gelf_getsym(symbols, GELF_R_SYM(rel.r_info), &sym)) { if (!gelf_getsym(symbols, GELF_R_SYM(rel.r_info), &sym)) {
pr_warn("relocation: symbol %zx not found\n", pr_warn("sec '%s': symbol 0x%zx not found for relo #%d\n",
(size_t)GELF_R_SYM(rel.r_info)); relo_sec_name, (size_t)GELF_R_SYM(rel.r_info), i);
return -LIBBPF_ERRNO__FORMAT; return -LIBBPF_ERRNO__FORMAT;
} }
if (rel.r_offset % sizeof(struct bpf_insn)) if (rel.r_offset % BPF_INSN_SZ) {
pr_warn("sec '%s': invalid offset 0x%zx for relo #%d\n",
relo_sec_name, (size_t)GELF_R_SYM(rel.r_info), i);
return -LIBBPF_ERRNO__FORMAT; return -LIBBPF_ERRNO__FORMAT;
}
insn_idx = rel.r_offset / sizeof(struct bpf_insn); insn_idx = rel.r_offset / BPF_INSN_SZ;
name = elf_sym_str(obj, sym.st_name) ?: "<?>"; sym_name = elf_sym_str(obj, sym.st_name) ?: "<?>";
pr_debug("relo for shdr %u, symb %zu, value %zu, type %d, bind %d, name %d (\'%s\'), insn %u\n", pr_debug("sec '%s': relo #%d: insn #%u against '%s'\n",
(__u32)sym.st_shndx, (size_t)GELF_R_SYM(rel.r_info), relo_sec_name, i, insn_idx, sym_name);
(size_t)sym.st_value, GELF_ST_TYPE(sym.st_info),
GELF_ST_BIND(sym.st_info), sym.st_name, name,
insn_idx);
err = bpf_program__record_reloc(prog, &prog->reloc_desc[i], err = bpf_program__record_reloc(prog, &prog->reloc_desc[i],
insn_idx, name, &sym, &rel); insn_idx, sym_name, &sym, &rel);
if (err) if (err)
return err; return err;
} }
@ -5155,9 +5170,9 @@ static int bpf_core_patch_insn(struct bpf_program *prog,
int insn_idx; int insn_idx;
__u8 class; __u8 class;
if (relo->insn_off % sizeof(struct bpf_insn)) if (relo->insn_off % BPF_INSN_SZ)
return -EINVAL; return -EINVAL;
insn_idx = relo->insn_off / sizeof(struct bpf_insn); insn_idx = relo->insn_off / BPF_INSN_SZ;
insn = &prog->insns[insn_idx]; insn = &prog->insns[insn_idx];
class = BPF_CLASS(insn->code); class = BPF_CLASS(insn->code);
@ -5588,7 +5603,7 @@ bpf_object__relocate_core(struct bpf_object *obj, const char *targ_btf_path)
goto out; goto out;
} }
pr_debug("prog '%s': performing %d CO-RE offset relocs\n", pr_debug("sec '%s': found %d CO-RE relocations\n",
sec_name, sec->num_info); sec_name, sec->num_info);
for_each_btf_ext_rec(seg, sec, i, rec) { for_each_btf_ext_rec(seg, sec, i, rec) {
@ -5596,7 +5611,7 @@ bpf_object__relocate_core(struct bpf_object *obj, const char *targ_btf_path)
targ_btf, cand_cache); targ_btf, cand_cache);
if (err) { if (err) {
pr_warn("prog '%s': relo #%d: failed to relocate: %d\n", pr_warn("prog '%s': relo #%d: failed to relocate: %d\n",
sec_name, i, err); prog->name, i, err);
goto out; goto out;
} }
} }
@ -5716,7 +5731,8 @@ bpf_program__relocate(struct bpf_program *prog, struct bpf_object *obj)
return err; return err;
break; break;
default: default:
pr_warn("relo #%d: bad relo type %d\n", i, relo->type); pr_warn("prog '%s': relo #%d: bad relo type %d\n",
prog->name, i, relo->type);
return -EINVAL; return -EINVAL;
} }
} }
@ -5751,7 +5767,8 @@ bpf_object__relocate(struct bpf_object *obj, const char *targ_btf_path)
err = bpf_program__relocate(prog, obj); err = bpf_program__relocate(prog, obj);
if (err) { if (err) {
pr_warn("failed to relocate '%s'\n", prog->section_name); pr_warn("prog '%s': failed to relocate data references: %d\n",
prog->name, err);
return err; return err;
} }
break; break;
@ -5766,7 +5783,8 @@ bpf_object__relocate(struct bpf_object *obj, const char *targ_btf_path)
err = bpf_program__relocate(prog, obj); err = bpf_program__relocate(prog, obj);
if (err) { if (err) {
pr_warn("failed to relocate '%s'\n", prog->section_name); pr_warn("prog '%s': failed to relocate calls: %d\n",
prog->name, err);
return err; return err;
} }
} }
@ -6198,8 +6216,7 @@ bpf_object__load_progs(struct bpf_object *obj, int log_level)
if (bpf_program__is_function_storage(prog, obj)) if (bpf_program__is_function_storage(prog, obj))
continue; continue;
if (!prog->load) { if (!prog->load) {
pr_debug("prog '%s'('%s'): skipped loading\n", pr_debug("prog '%s': skipped loading\n", prog->name);
prog->name, prog->section_name);
continue; continue;
} }
prog->log_level |= log_level; prog->log_level |= log_level;
@ -7343,7 +7360,7 @@ int bpf_program__fd(const struct bpf_program *prog)
size_t bpf_program__size(const struct bpf_program *prog) size_t bpf_program__size(const struct bpf_program *prog)
{ {
return prog->insns_cnt * sizeof(struct bpf_insn); return prog->insns_cnt * BPF_INSN_SZ;
} }
int bpf_program__set_prep(struct bpf_program *prog, int nr_instances, int bpf_program__set_prep(struct bpf_program *prog, int nr_instances,