libbpf: Record subprog-resolved CO-RE relocations unconditionally

Previously, libbpf recorded CO-RE relocations with insns_idx resolved
according to finalized subprog locations (which are appended at the end
of entry BPF program) to simplify the job of light skeleton generator.

This is necessary because once subprogs' instructions are appended to
main entry BPF program all the subprog instruction indices are shifted
and that shift is different for each entry (main) BPF program, so it's
generally impossible to map final absolute insn_idx of the finalized BPF
program to their original locations inside subprograms.

This information is now going to be used not only during light skeleton
generation, but also to map absolute instruction index to subprog's
instruction and its corresponding CO-RE relocation. So start recording
these relocations always, not just when obj->gen_loader is set.

This information is going to be freed at the end of bpf_object__load()
step, as before (but this can change in the future if there will be
a need for this information post load step).

Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20220426004511.2691730-7-andrii@kernel.org

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 81f2b98..109fc86 100644 (file)
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -5749,16 +5749,16 @@ bpf_object__relocate_core(struct bpf_object *obj, const char *targ_btf_path)
                                return -EINVAL;
                        insn = &prog->insns[insn_idx];
 
-                       if (prog->obj->gen_loader) {
-                               err = record_relo_core(prog, rec, insn_idx);
-                               if (err) {
-                                       pr_warn("prog '%s': relo #%d: failed to record relocation: %d\n",
-                                               prog->name, i, err);
-                                       goto out;
-                               }
-                               continue;
+                       err = record_relo_core(prog, rec, insn_idx);
+                       if (err) {
+                               pr_warn("prog '%s': relo #%d: failed to record relocation: %d\n",
+                                       prog->name, i, err);
+                               goto out;
                        }
 
+                       if (prog->obj->gen_loader)
+                               continue;
+
                        err = bpf_core_resolve_relo(prog, rec, i, obj->btf, cand_cache, &targ_res);
                        if (err) {
                                pr_warn("prog '%s': relo #%d: failed to relocate: %d\n",
@@ -6299,7 +6299,6 @@ bpf_object__relocate_calls(struct bpf_object *obj, struct bpf_program *prog)
        if (err)
                return err;
 
-
        return 0;
 }
 
@@ -6360,8 +6359,7 @@ bpf_object__relocate(struct bpf_object *obj, const char *targ_btf_path)
                                err);
                        return err;
                }
-               if (obj->gen_loader)
-                       bpf_object__sort_relos(obj);
+               bpf_object__sort_relos(obj);
        }
 
        /* Before relocating calls pre-process relocations and mark
@@ -6421,8 +6419,7 @@ bpf_object__relocate(struct bpf_object *obj, const char *targ_btf_path)
                        return err;
                }
        }
-       if (!obj->gen_loader)
-               bpf_object__free_relocs(obj);
+
        return 0;
 }
 
@@ -7014,8 +7011,8 @@ bpf_object__load_progs(struct bpf_object *obj, int log_level)
                if (err)
                        return err;
        }
-       if (obj->gen_loader)
-               bpf_object__free_relocs(obj);
+
+       bpf_object__free_relocs(obj);
        return 0;
 }