tools lib bpf: Introduce bpf_program__get_prog_info_linear()

Currently, bpf_prog_info includes 9 arrays. The user has the option to
fetch any combination of these arrays. However, this requires a lot of
handling.

This work becomes more tricky when we need to store bpf_prog_info to a
file, because these arrays are allocated independently.

This patch introduces 'struct bpf_prog_info_linear', which stores arrays
of bpf_prog_info in continuous memory.

Helper functions are introduced to unify the work to get different sets
of bpf_prog_info.  Specifically, bpf_program__get_prog_info_linear()
allows the user to select which arrays to fetch, and handles details for
the user.

Please see the comments right before 'enum bpf_prog_info_array' for more
details and examples.

Signed-off-by: Song Liu <songliubraving@fb.com>
Reviewed-by: Jiri Olsa <jolsa@kernel.org>
Acked-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lkml.kernel.org/r/ce92c091-e80d-a0c1-4aa0-987706c42b20@iogearbox.net
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Alexei Starovoitov <ast@kernel.org>
Cc: kernel-team@fb.com
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stanislav Fomichev <sdf@google.com>
Link: http://lkml.kernel.org/r/20190312053051.2690567-3-songliubraving@fb.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

3 files changed, 317 insertions, 0 deletions

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 4884557aa17f..8fb6e89b4b2c 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -112,6 +112,11 @@ void libbpf_print(enum libbpf_print_level level, const char *format, ...)
 # define LIBBPF_ELF_C_READ_MMAP ELF_C_READ
 #endif
 
+static inline __u64 ptr_to_u64(const void *ptr)
+{
+        return (__u64) (unsigned long) ptr;
+}
+
 struct bpf_capabilities {
         /* v4.14: kernel support for program & map names. */
         __u32 name:1;
@@ -2997,3 +3002,249 @@ bpf_perf_event_read_simple(void *mmap_mem, size_t mmap_size, size_t page_size,
         ring_buffer_write_tail(header, data_tail);
         return ret;
 }
+
+struct bpf_prog_info_array_desc {
+        int     array_offset;   /* e.g. offset of jited_prog_insns */
+        int     count_offset;   /* e.g. offset of jited_prog_len */
+        int     size_offset;    /* > 0: offset of rec size,
+                                 * < 0: fix size of -size_offset
+                                 */
+};
+
+static struct bpf_prog_info_array_desc bpf_prog_info_array_desc[] = {
+        [BPF_PROG_INFO_JITED_INSNS] = {
+                offsetof(struct bpf_prog_info, jited_prog_insns),
+                offsetof(struct bpf_prog_info, jited_prog_len),
+                -1,
+        },
+        [BPF_PROG_INFO_XLATED_INSNS] = {
+                offsetof(struct bpf_prog_info, xlated_prog_insns),
+                offsetof(struct bpf_prog_info, xlated_prog_len),
+                -1,
+        },
+        [BPF_PROG_INFO_MAP_IDS] = {
+                offsetof(struct bpf_prog_info, map_ids),
+                offsetof(struct bpf_prog_info, nr_map_ids),
+                -(int)sizeof(__u32),
+        },
+        [BPF_PROG_INFO_JITED_KSYMS] = {
+                offsetof(struct bpf_prog_info, jited_ksyms),
+                offsetof(struct bpf_prog_info, nr_jited_ksyms),
+                -(int)sizeof(__u64),
+        },
+        [BPF_PROG_INFO_JITED_FUNC_LENS] = {
+                offsetof(struct bpf_prog_info, jited_func_lens),
+                offsetof(struct bpf_prog_info, nr_jited_func_lens),
+                -(int)sizeof(__u32),
+        },
+        [BPF_PROG_INFO_FUNC_INFO] = {
+                offsetof(struct bpf_prog_info, func_info),
+                offsetof(struct bpf_prog_info, nr_func_info),
+                offsetof(struct bpf_prog_info, func_info_rec_size),
+        },
+        [BPF_PROG_INFO_LINE_INFO] = {
+                offsetof(struct bpf_prog_info, line_info),
+                offsetof(struct bpf_prog_info, nr_line_info),
+                offsetof(struct bpf_prog_info, line_info_rec_size),
+        },
+        [BPF_PROG_INFO_JITED_LINE_INFO] = {
+                offsetof(struct bpf_prog_info, jited_line_info),
+                offsetof(struct bpf_prog_info, nr_jited_line_info),
+                offsetof(struct bpf_prog_info, jited_line_info_rec_size),
+        },
+        [BPF_PROG_INFO_PROG_TAGS] = {
+                offsetof(struct bpf_prog_info, prog_tags),
+                offsetof(struct bpf_prog_info, nr_prog_tags),
+                -(int)sizeof(__u8) * BPF_TAG_SIZE,
+        },
+
+};
+
+static __u32 bpf_prog_info_read_offset_u32(struct bpf_prog_info *info, int offset)
+{
+        __u32 *array = (__u32 *)info;
+
+        if (offset >= 0)
+                return array[offset / sizeof(__u32)];
+        return -(int)offset;
+}
+
+static __u64 bpf_prog_info_read_offset_u64(struct bpf_prog_info *info, int offset)
+{
+        __u64 *array = (__u64 *)info;
+
+        if (offset >= 0)
+                return array[offset / sizeof(__u64)];
+        return -(int)offset;
+}
+
+static void bpf_prog_info_set_offset_u32(struct bpf_prog_info *info, int offset,
+                                         __u32 val)
+{
+        __u32 *array = (__u32 *)info;
+
+        if (offset >= 0)
+                array[offset / sizeof(__u32)] = val;
+}
+
+static void bpf_prog_info_set_offset_u64(struct bpf_prog_info *info, int offset,
+                                         __u64 val)
+{
+        __u64 *array = (__u64 *)info;
+
+        if (offset >= 0)
+                array[offset / sizeof(__u64)] = val;
+}
+
+struct bpf_prog_info_linear *
+bpf_program__get_prog_info_linear(int fd, __u64 arrays)
+{
+        struct bpf_prog_info_linear *info_linear;
+        struct bpf_prog_info info = {};
+        __u32 info_len = sizeof(info);
+        __u32 data_len = 0;
+        int i, err;
+        void *ptr;
+
+        if (arrays >> BPF_PROG_INFO_LAST_ARRAY)
+                return ERR_PTR(-EINVAL);
+
+        /* step 1: get array dimensions */
+        err = bpf_obj_get_info_by_fd(fd, &info, &info_len);
+        if (err) {
+                pr_debug("can't get prog info: %s", strerror(errno));
+                return ERR_PTR(-EFAULT);
+        }
+
+        /* step 2: calculate total size of all arrays */
+        for (i = BPF_PROG_INFO_FIRST_ARRAY; i < BPF_PROG_INFO_LAST_ARRAY; ++i) {
+                bool include_array = (arrays & (1UL << i)) > 0;
+                struct bpf_prog_info_array_desc *desc;
+                __u32 count, size;
+
+                desc = bpf_prog_info_array_desc + i;
+
+                /* kernel is too old to support this field */
+                if (info_len < desc->array_offset + sizeof(__u32) ||
+                    info_len < desc->count_offset + sizeof(__u32) ||
+                    (desc->size_offset > 0 && info_len < desc->size_offset))
+                        include_array = false;
+
+                if (!include_array) {
+                        arrays &= ~(1UL << i);  /* clear the bit */
+                        continue;
+                }
+
+                count = bpf_prog_info_read_offset_u32(&info, desc->count_offset);
+                size  = bpf_prog_info_read_offset_u32(&info, desc->size_offset);
+
+                data_len += count * size;
+        }
+
+        /* step 3: allocate continuous memory */
+        data_len = roundup(data_len, sizeof(__u64));
+        info_linear = malloc(sizeof(struct bpf_prog_info_linear) + data_len);
+        if (!info_linear)
+                return ERR_PTR(-ENOMEM);
+
+        /* step 4: fill data to info_linear->info */
+        info_linear->arrays = arrays;
+        memset(&info_linear->info, 0, sizeof(info));
+        ptr = info_linear->data;
+
+        for (i = BPF_PROG_INFO_FIRST_ARRAY; i < BPF_PROG_INFO_LAST_ARRAY; ++i) {
+                struct bpf_prog_info_array_desc *desc;
+                __u32 count, size;
+
+                if ((arrays & (1UL << i)) == 0)
+                        continue;
+
+                desc  = bpf_prog_info_array_desc + i;
+                count = bpf_prog_info_read_offset_u32(&info, desc->count_offset);
+                size  = bpf_prog_info_read_offset_u32(&info, desc->size_offset);
+                bpf_prog_info_set_offset_u32(&info_linear->info,
+                                             desc->count_offset, count);
+                bpf_prog_info_set_offset_u32(&info_linear->info,
+                                             desc->size_offset, size);
+                bpf_prog_info_set_offset_u64(&info_linear->info,
+                                             desc->array_offset,
+                                             ptr_to_u64(ptr));
+                ptr += count * size;
+        }
+
+        /* step 5: call syscall again to get required arrays */
+        err = bpf_obj_get_info_by_fd(fd, &info_linear->info, &info_len);
+        if (err) {
+                pr_debug("can't get prog info: %s", strerror(errno));
+                free(info_linear);
+                return ERR_PTR(-EFAULT);
+        }
+
+        /* step 6: verify the data */
+        for (i = BPF_PROG_INFO_FIRST_ARRAY; i < BPF_PROG_INFO_LAST_ARRAY; ++i) {
+                struct bpf_prog_info_array_desc *desc;
+                __u32 v1, v2;
+