A light skeleton does not call bpf_prog_load(). bpf_gen__prog_load() builds its own union bpf_attr field by field, and the loader program it emits is what issues BPF_PROG_LOAD when the skeleton runs -- so a program loaded this way reached the kernel without the table the previous patch collected for it. The load then fails, because the landing pads are code nothing reaches and the verifier says so. It says "unreachable insn", which names neither the skeleton nor the table. Carry it the way func_info and line_info are carried: the records go into the loader's blob of bytes, the count and record size into the attr, and a relocation stores the blob's address into attr.cleanup_info once that address is known. The attr grows to its new last field, cleanup_info_cnt. Records are 4-byte fields like the other info blobs, so a cross-endian build has to swap them too. Growing the attr is what makes the relocation conditional. Every other attr in this file stops at the last field it sets, and this one now runs to the end of the union: a kernel that predates cleanup_info accepts an attr longer than its own only while the tail it does not know reads as zero. The count and the record size are already zero for a program with no table, but the relocation stores a blob address, which never is, so a program that has no landing pads only keeps loading on such a kernel if the relocation is left out. Signed-off-by: Yonghong Song --- tools/lib/bpf/gen_loader.c | 29 +++++++++++++++++++++++++---- tools/lib/bpf/libbpf_internal.h | 7 +++++++ 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/tools/lib/bpf/gen_loader.c b/tools/lib/bpf/gen_loader.c index af3a04f161ac..2345fbdd46f5 100644 --- a/tools/lib/bpf/gen_loader.c +++ b/tools/lib/bpf/gen_loader.c @@ -981,13 +981,15 @@ static void cleanup_relos(struct bpf_gen *gen, int insns) cleanup_core_relo(gen); } -/* Convert func, line, and core relo info blobs to target endianness */ +/* Convert func, line, core relo and cleanup info blobs to target endianness */ static void info_blob_bswap(struct bpf_gen *gen, int func_info, int line_info, - int core_relos, struct bpf_prog_load_opts *load_attr) + int core_relos, int cleanup_info, + struct bpf_prog_load_opts *load_attr) { struct bpf_func_info *fi = gen->data_start + func_info; struct bpf_line_info *li = gen->data_start + line_info; struct bpf_core_relo *cr = gen->data_start + core_relos; + struct bpf_cleanup_info *ci = gen->data_start + cleanup_info; int i; for (i = 0; i < load_attr->func_info_cnt; i++) @@ -998,6 +1000,9 @@ static void info_blob_bswap(struct bpf_gen *gen, int func_info, int line_info, for (i = 0; i < gen->core_relo_cnt; i++) bpf_core_relo_bswap(cr++); + + for (i = 0; i < load_attr->cleanup_info_cnt; i++) + bpf_cleanup_info_bswap(ci++); } void bpf_gen__prog_load(struct bpf_gen *gen, @@ -1011,8 +1016,11 @@ void bpf_gen__prog_load(struct bpf_gen *gen, load_attr->line_info_rec_size; int core_relo_tot_sz = gen->core_relo_cnt * sizeof(struct bpf_core_relo); + int cleanup_info_tot_sz = load_attr->cleanup_info_cnt * + load_attr->cleanup_info_rec_size; int prog_load_attr, license_off, insns_off, func_info, line_info, core_relos; - int attr_size = offsetofend(union bpf_attr, core_relo_rec_size); + int attr_size = offsetofend(union bpf_attr, cleanup_info_cnt); + int cleanup_info; union bpf_attr attr; memset(&attr, 0, attr_size); @@ -1061,9 +1069,17 @@ void bpf_gen__prog_load(struct bpf_gen *gen, core_relos, gen->core_relo_cnt, sizeof(struct bpf_core_relo)); + attr.cleanup_info_rec_size = tgt_endian(load_attr->cleanup_info_rec_size); + attr.cleanup_info_cnt = tgt_endian(load_attr->cleanup_info_cnt); + cleanup_info = add_data(gen, load_attr->cleanup_info, cleanup_info_tot_sz); + pr_debug("gen: prog_load: cleanup_info: off %d cnt %u rec size %u\n", + cleanup_info, load_attr->cleanup_info_cnt, + load_attr->cleanup_info_rec_size); + /* convert all info blobs to target endianness */ if (gen->swapped_endian && !gen->error) - info_blob_bswap(gen, func_info, line_info, core_relos, load_attr); + info_blob_bswap(gen, func_info, line_info, core_relos, cleanup_info, + load_attr); libbpf_strlcpy(attr.prog_name, prog_name, sizeof(attr.prog_name)); prog_load_attr = add_data(gen, &attr, attr_size); @@ -1085,6 +1101,11 @@ void bpf_gen__prog_load(struct bpf_gen *gen, /* populate union bpf_attr with a pointer to core_relos */ emit_rel_store(gen, attr_field(prog_load_attr, core_relos), core_relos); + /* populate union bpf_attr with a pointer to cleanup_info, if there is one */ + if (load_attr->cleanup_info_cnt) + emit_rel_store(gen, attr_field(prog_load_attr, cleanup_info), + cleanup_info); + /* populate union bpf_attr fd_array with a pointer to data where map_fds are saved */ emit_rel_store(gen, attr_field(prog_load_attr, fd_array), gen->fd_array); diff --git a/tools/lib/bpf/libbpf_internal.h b/tools/lib/bpf/libbpf_internal.h index 3ba6d9090368..78519f24fb40 100644 --- a/tools/lib/bpf/libbpf_internal.h +++ b/tools/lib/bpf/libbpf_internal.h @@ -572,6 +572,13 @@ static inline void bpf_core_relo_bswap(struct bpf_core_relo *i) i->kind = bswap_32(i->kind); } +static inline void bpf_cleanup_info_bswap(struct bpf_cleanup_info *i) +{ + i->begin_off = bswap_32(i->begin_off); + i->end_off = bswap_32(i->end_off); + i->landing_pad_off = bswap_32(i->landing_pad_off); +} + enum btf_field_iter_kind { BTF_FIELD_ITER_IDS, BTF_FIELD_ITER_STRS, -- 2.53.0-Meta