libbpf: Add typeless ksym support to gen_loader

This uses the bpf_kallsyms_lookup_name helper added in previous patches
to relocate typeless ksyms. The return value ENOENT can be ignored, and
the value written to 'res' can be directly stored to the insn, as it is
overwritten to 0 on lookup failure. For repeating symbols, we can simply
copy the previously populated bpf_insn.

Also, we need to take care to not close fds for typeless ksym_desc, so
reuse the 'off' member's space to add a marker for typeless ksym and use
that to skip them in cleanup_relos.

We add a emit_ksym_relo_log helper that avoids duplicating common
logging instructions between typeless and weak ksym (for future commit).

Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20211028063501.2239335-3-memxor@gmail.com

diff --git a/tools/lib/bpf/bpf_gen_internal.h b/tools/lib/bpf/bpf_gen_internal.h
index b8d41d6fbc40702794e8ed724291c4d7efd5d00d..d26e5472fe501633b99b805d137ab806b7a06fa6 100644 (file)
--- a/tools/lib/bpf/bpf_gen_internal.h
+++ b/tools/lib/bpf/bpf_gen_internal.h
@@ -8,13 +8,19 @@ struct ksym_relo_desc {
        int kind;
        int insn_idx;
        bool is_weak;
+       bool is_typeless;
 };
 
 struct ksym_desc {
        const char *name;
        int ref;
        int kind;
-       int off;
+       union {
+               /* used for kfunc */
+               int off;
+               /* used for typeless ksym */
+               bool typeless;
+       };
        int insn;
 };
 
@@ -49,7 +55,7 @@ void bpf_gen__prog_load(struct bpf_gen *gen, struct bpf_prog_load_params *load_a
 void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *value, __u32 value_size);
 void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx);
 void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *name, enum bpf_attach_type type);
-void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak, int kind,
-                           int insn_idx);
+void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak,
+                           bool is_typeless, int kind, int insn_idx);
 
 #endif

diff --git a/tools/lib/bpf/gen_loader.c b/tools/lib/bpf/gen_loader.c
index e552484ae4a4869afd54f9efdff5f3c560d05f79..bae065a9dbeca3eed3de52887d0c5fc972d29b09 100644 (file)
--- a/tools/lib/bpf/gen_loader.c
+++ b/tools/lib/bpf/gen_loader.c
@@ -560,7 +560,7 @@ static void emit_find_attach_target(struct bpf_gen *gen)
 }
 
 void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak,
-                           int kind, int insn_idx)
+                           bool is_typeless, int kind, int insn_idx)
 {
        struct ksym_relo_desc *relo;
 
@@ -573,6 +573,7 @@ void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, bool is_weak,
        relo += gen->relo_cnt;
        relo->name = name;
        relo->is_weak = is_weak;
+       relo->is_typeless = is_typeless;
        relo->kind = kind;
        relo->insn_idx = insn_idx;
        gen->relo_cnt++;
@@ -622,6 +623,29 @@ static void emit_bpf_find_by_name_kind(struct bpf_gen *gen, struct ksym_relo_des
        debug_ret(gen, "find_by_name_kind(%s,%d)", relo->name, relo->kind);
 }
 
+/* Overwrites BPF_REG_{0, 1, 2, 3, 4, 7}
+ * Returns result in BPF_REG_7
+ * Returns u64 symbol addr in BPF_REG_9
+ */
+static void emit_bpf_kallsyms_lookup_name(struct bpf_gen *gen, struct ksym_relo_desc *relo)
+{
+       int name_off, len = strlen(relo->name) + 1, res_off;
+
+       name_off = add_data(gen, relo->name, len);
+       res_off = add_data(gen, NULL, 8); /* res is u64 */
+       emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_1, BPF_PSEUDO_MAP_IDX_VALUE,
+                                        0, 0, 0, name_off));
+       emit(gen, BPF_MOV64_IMM(BPF_REG_2, len));
+       emit(gen, BPF_MOV64_IMM(BPF_REG_3, 0));
+       emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_4, BPF_PSEUDO_MAP_IDX_VALUE,
+                                        0, 0, 0, res_off));
+       emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_4));
+       emit(gen, BPF_EMIT_CALL(BPF_FUNC_kallsyms_lookup_name));
+       emit(gen, BPF_LDX_MEM(BPF_DW, BPF_REG_9, BPF_REG_7, 0));
+       emit(gen, BPF_MOV64_REG(BPF_REG_7, BPF_REG_0));
+       debug_ret(gen, "kallsyms_lookup_name(%s,%d)", relo->name, relo->kind);
+}
+
 /* Expects:
  * BPF_REG_8 - pointer to instruction
  *
@@ -701,6 +725,58 @@ log:
                   relo->name, kdesc->ref);
 }
 
+static void emit_ksym_relo_log(struct bpf_gen *gen, struct ksym_relo_desc *relo,
+                              int ref)
+{
+       if (!gen->log_level)
+               return;
+       emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_8,
+                             offsetof(struct bpf_insn, imm)));
+       emit(gen, BPF_LDX_MEM(BPF_H, BPF_REG_9, BPF_REG_8, sizeof(struct bpf_insn) +
+                             offsetof(struct bpf_insn, imm)));
+       debug_regs(gen, BPF_REG_7, BPF_REG_9, " var t=%d w=%d (%s:count=%d): imm[0]: %%d, imm[1]: %%d",
+                  relo->is_typeless, relo->is_weak, relo->name, ref);
+       emit(gen, BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_8, offsetofend(struct bpf_insn, code)));
+       debug_regs(gen, BPF_REG_9, -1, " var t=%d w=%d (%s:count=%d): insn.reg",
+                  relo->is_typeless, relo->is_weak, relo->name, ref);
+}
+
+/* Expects:
+ * BPF_REG_8 - pointer to instruction
+ */
+static void emit_relo_ksym_typeless(struct bpf_gen *gen,
+                                   struct ksym_relo_desc *relo, int insn)
+{
+       struct ksym_desc *kdesc;
+
+       kdesc = get_ksym_desc(gen, relo);
+       if (!kdesc)
+               return;
+       /* try to copy from existing ldimm64 insn */
+       if (kdesc->ref > 1) {
+               move_blob2blob(gen, insn + offsetof(struct bpf_insn, imm), 4,
+                              kdesc->insn + offsetof(struct bpf_insn, imm));
+               move_blob2blob(gen, insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm), 4,
+                              kdesc->insn + sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm));
+               goto log;
+       }
+       /* remember insn offset, so we can copy ksym addr later */
+       kdesc->insn = insn;
+       /* skip typeless ksym_desc in fd closing loop in cleanup_relos */
+       kdesc->typeless = true;
+       emit_bpf_kallsyms_lookup_name(gen, relo);
+       emit(gen, BPF_JMP_IMM(BPF_JEQ, BPF_REG_7, -ENOENT, 1));
+       emit_check_err(gen);
+       /* store lower half of addr into insn[insn_idx].imm */
+       emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_9, offsetof(struct bpf_insn, imm)));
+       /* store upper half of addr into insn[insn_idx + 1].imm */
+       emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_9, 32));
+       emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_9,
+                     sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm)));
+log:
+       emit_ksym_relo_log(gen, relo, kdesc->ref);
+}
+
 /* Expects:
  * BPF_REG_8 - pointer to instruction
  */
@@ -730,14 +806,7 @@ static void emit_relo_ksym_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo,
        emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_8, BPF_REG_7,
                              sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm)));
 log:
-       if (!gen->log_level)
-               return;
-       emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_7, BPF_REG_8,
-                             offsetof(struct bpf_insn, imm)));
-       emit(gen, BPF_LDX_MEM(BPF_H, BPF_REG_9, BPF_REG_8, sizeof(struct bpf_insn) +
-                             offsetof(struct bpf_insn, imm)));
-       debug_regs(gen, BPF_REG_7, BPF_REG_9, " var (%s:count=%d): imm: %%d, fd: %%d",
-                  relo->name, kdesc->ref);
+       emit_ksym_relo_log(gen, relo, kdesc->ref);
 }
 
 static void emit_relo(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insns)
@@ -749,7 +818,10 @@ static void emit_relo(struct bpf_gen *gen, struct ksym_relo_desc *relo, int insn
        emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_8, BPF_PSEUDO_MAP_IDX_VALUE, 0, 0, 0, insn));
        switch (relo->kind) {
        case BTF_KIND_VAR:
-               emit_relo_ksym_btf(gen, relo, insn);
+               if (relo->is_typeless)
+                       emit_relo_ksym_typeless(gen, relo, insn);
+               else
+                       emit_relo_ksym_btf(gen, relo, insn);
                break;
        case BTF_KIND_FUNC:
                emit_relo_kfunc_btf(gen, relo, insn);
@@ -774,12 +846,13 @@ static void cleanup_relos(struct bpf_gen *gen, int insns)
        int i, insn;
 
        for (i = 0; i < gen->nr_ksyms; i++) {
-               if (gen->ksyms[i].kind == BTF_KIND_VAR) {
+               /* only close fds for typed ksyms and kfuncs */
+               if (gen->ksyms[i].kind == BTF_KIND_VAR && !gen->ksyms[i].typeless) {
                        /* close fd recorded in insn[insn_idx + 1].imm */
                        insn = gen->ksyms[i].insn;
                        insn += sizeof(struct bpf_insn) + offsetof(struct bpf_insn, imm);
                        emit_sys_close_blob(gen, insn);
-               } else { /* BTF_KIND_FUNC */
+               } else if (gen->ksyms[i].kind == BTF_KIND_FUNC) {
                        emit_sys_close_blob(gen, blob_fd_array_off(gen, gen->ksyms[i].off));
                        if (gen->ksyms[i].off < MAX_FD_ARRAY_SZ)
                                gen->nr_fd_array--;

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 232e4efe82e905248af6d770f3895fd8782e97fa..73e1e70a722f6321ab7e46ffbded4a1f19c881fe 100644 (file)
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -6575,17 +6575,14 @@ static int bpf_program__record_externs(struct bpf_program *prog)
                case RELO_EXTERN_VAR:
                        if (ext->type != EXT_KSYM)
                                continue;
-                       if (!ext->ksym.type_id) {
-                               pr_warn("typeless ksym %s is not supported yet\n",
-                                       ext->name);
-                               return -ENOTSUP;
-                       }
-                       bpf_gen__record_extern(obj->gen_loader, ext->name, ext->is_weak,
+                       bpf_gen__record_extern(obj->gen_loader, ext->name,
+                                              ext->is_weak, !ext->ksym.type_id,
                                               BTF_KIND_VAR, relo->insn_idx);
                        break;
                case RELO_EXTERN_FUNC:
-                       bpf_gen__record_extern(obj->gen_loader, ext->name, ext->is_weak,
-                                              BTF_KIND_FUNC, relo->insn_idx);
+                       bpf_gen__record_extern(obj->gen_loader, ext->name,
+                                              ext->is_weak, false, BTF_KIND_FUNC,
+                                              relo->insn_idx);
                        break;
                default:
                        continue;