bpf, libbpf: add support for BTF Var and DataSec

This adds libbpf support for BTF Var and DataSec kinds. Main point
here is that libbpf needs to do some preparatory work before the
whole BTF object can be loaded into the kernel, that is, fixing up
of DataSec size taken from the ELF section size and non-static
variable offset which needs to be taken from the ELF's string section.

Upstream LLVM doesn't fix these up since at time of BTF emission
it is too early in the compilation process thus this information
isn't available yet, hence loader needs to take care of it.

Note, deduplication handling has not been in the scope of this work
and needs to be addressed in a future commit.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://reviews.llvm.org/D59441
Acked-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

1 files changed, 131 insertions, 19 deletions

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index f7b245fbb960..e2a457e7c318 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -669,6 +669,112 @@ static bool bpf_map_type__is_map_in_map(enum bpf_map_type type)
         return false;
 }
 
+static int bpf_object_search_section_size(const struct bpf_object *obj,
+                                          const char *name, size_t *d_size)
+{
+        const GElf_Ehdr *ep = &obj->efile.ehdr;
+        Elf *elf = obj->efile.elf;
+        Elf_Scn *scn = NULL;
+        int idx = 0;
+
+        while ((scn = elf_nextscn(elf, scn)) != NULL) {
+                const char *sec_name;
+                Elf_Data *data;
+                GElf_Shdr sh;
+
+                idx++;
+                if (gelf_getshdr(scn, &sh) != &sh) {
+                        pr_warning("failed to get section(%d) header from %s\n",
+                                   idx, obj->path);
+                        return -EIO;
+                }
+
+                sec_name = elf_strptr(elf, ep->e_shstrndx, sh.sh_name);
+                if (!sec_name) {
+                        pr_warning("failed to get section(%d) name from %s\n",
+                                   idx, obj->path);
+                        return -EIO;
+                }
+
+                if (strcmp(name, sec_name))
+                        continue;
+
+                data = elf_getdata(scn, 0);
+                if (!data) {
+                        pr_warning("failed to get section(%d) data from %s(%s)\n",
+                                   idx, name, obj->path);
+                        return -EIO;
+                }
+
+                *d_size = data->d_size;
+                return 0;
+        }
+
+        return -ENOENT;
+}
+
+int bpf_object__section_size(const struct bpf_object *obj, const char *name,
+                             __u32 *size)
+{
+        int ret = -ENOENT;
+        size_t d_size;
+
+        *size = 0;
+        if (!name) {
+                return -EINVAL;
+        } else if (!strcmp(name, ".data")) {
+                if (obj->efile.data)
+                        *size = obj->efile.data->d_size;
+        } else if (!strcmp(name, ".bss")) {
+                if (obj->efile.bss)
+                        *size = obj->efile.bss->d_size;
+        } else if (!strcmp(name, ".rodata")) {
+                if (obj->efile.rodata)
+                        *size = obj->efile.rodata->d_size;
+        } else {
+                ret = bpf_object_search_section_size(obj, name, &d_size);
+                if (!ret)
+                        *size = d_size;
+        }
+
+        return *size ? 0 : ret;
+}
+
+int bpf_object__variable_offset(const struct bpf_object *obj, const char *name,
+                                __u32 *off)
+{
+        Elf_Data *symbols = obj->efile.symbols;
+        const char *sname;
+        size_t si;
+
+        if (!name || !off)
+                return -EINVAL;
+
+        for (si = 0; si < symbols->d_size / sizeof(GElf_Sym); si++) {
+                GElf_Sym sym;
+
+                if (!gelf_getsym(symbols, si, &sym))
+                        continue;
+                if (GELF_ST_BIND(sym.st_info) != STB_GLOBAL ||
+                    GELF_ST_TYPE(sym.st_info) != STT_OBJECT)
+                        continue;
+
+                sname = elf_strptr(obj->efile.elf, obj->efile.strtabidx,
+                                   sym.st_name);
+                if (!sname) {
+                        pr_warning("failed to get sym name string for var %s\n",
+                                   name);
+                        return -EIO;
+                }
+                if (strcmp(name, sname) == 0) {
+                        *off = sym.st_value;
+                        return 0;
+                }
+        }
+
+        return -ENOENT;
+}
+
 static bool bpf_object__has_maps(const struct bpf_object *obj)
 {
         return obj->efile.maps_shndx >= 0 ||
@@ -911,6 +1017,7 @@ static int bpf_object__elf_collect(struct bpf_object *obj, int flags)
         Elf *elf = obj->efile.elf;
         GElf_Ehdr *ep = &obj->efile.ehdr;
         Elf_Data *btf_ext_data = NULL;
+        Elf_Data *btf_data = NULL;
         Elf_Scn *scn = NULL;
         int idx = 0, err = 0;
 
@@ -954,32 +1061,18 @@ static int bpf_object__elf_collect(struct bpf_object *obj, int flags)
                          (int)sh.sh_link, (unsigned long)sh.sh_flags,
                          (int)sh.sh_type);
 
-                if (strcmp(name, "license") == 0)
+                if (strcmp(name, "license") == 0) {
                         err = bpf_object__init_license(obj,
                                                        data->d_buf,
                                                        data->d_size);
-                else if (strcmp(name, "version") == 0)
+                } else if (strcmp(name, "version") == 0) {
                         err = bpf_object__init_kversion(obj,
                                                         data->d_buf,
                                                         data->d_size);
-                else if (strcmp(name, "maps") == 0)
+                } else if (strcmp(name, "maps") == 0) {
                         obj->efile.maps_shndx = idx;
-                else if (strcmp(name, BTF_ELF_SEC) == 0) {
-                        obj->btf = btf__new(data->d_buf, data->d_size);
-                        if (IS_ERR(obj->btf)) {
-                                pr_warning("Error loading ELF section %s: %ld. Ignored and continue.\n",
-                                           BTF_ELF_SEC, PTR_ERR(obj->btf));
-                                obj->btf = NULL;
-                                continue;
-                        }
-                        err = btf__load(obj->btf);
-                        if (err) {
-                                pr_warning("Error loading %s into kernel: %d. Ignored and continue.\n",
-                                           BTF_ELF_SEC, err);
-                                btf__free(obj->btf);
-                                obj->btf = NULL;
-                                err = 0;
-                        }
+                } else if (strcmp(name, BTF_ELF_SEC) == 0) {
+                        btf_data = data;
                 } else if (strcmp(name, BTF_EXT_ELF_SEC) == 0) {
                         btf_ext_data = data;
                 } else if (sh.sh_type == SHT_SYMTAB) {
@@ -1054,6 +1147,25 @@ static int bpf_object__elf_collect(struct bpf_object *obj, int flags)
                 pr_warning("Corrupted ELF file: index of strtab invalid\n");
                 return LIBBPF_ERRNO__FORMAT;
         }
+        if (btf_data) {
+                obj->btf = btf__new(btf_data->d_buf, btf_data->d_size);
+                if (IS_ERR(obj->btf)) {
+                        pr_warning("Error loading ELF section %s: %ld. Ignored and continue.\n",
+                                   BTF_ELF_SEC, PTR_ERR(obj->btf));
+                        obj->btf = NULL;
+                } else {
+                        err = btf__finalize_data(obj, obj->btf);
+                        if (!err)
+                                err = btf__load(obj->btf);
+                        if (err) {
+                                pr_warning("Error finalizing and loading %s into kernel: %d. Ignored and continue.\n",
+                                           BTF_ELF_SEC, err);
+                                btf__free(obj->btf);
+                                obj->btf = NULL;
+                                err = 0;
+                        }
+                }
+        }
         if (btf_ext_data) {
                 if (!obj->btf) {
                         pr_debug("Ignore ELF section %s because its depending ELF section %s is not found.\n",