6 files changed, 144 insertions, 2 deletions

diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index a11cb006f968..72df4b6fa36f 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -298,6 +298,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
                 use_pager = 1;
         commit_pager_choice();
 
+        perf_env__init(&perf_env);
         perf_env__set_cmdline(&perf_env, argc, argv);
         status = p->fn(argc, argv);
         perf_config__exit();
diff --git a/tools/perf/util/bpf-event.c b/tools/perf/util/bpf-event.c
index 5237e8f11997..37ee4e2a728a 100644
--- a/tools/perf/util/bpf-event.c
+++ b/tools/perf/util/bpf-event.c
@@ -10,6 +10,7 @@
 #include "debug.h"
 #include "symbol.h"
 #include "machine.h"
+#include "env.h"
 #include "session.h"
 
 #define ptr_to_u64(ptr)    ((__u64)(unsigned long)(ptr))
@@ -54,17 +55,28 @@ static int perf_event__synthesize_one_bpf_prog(struct perf_session *session,
         struct bpf_event *bpf_event = &event->bpf_event;
         struct bpf_prog_info_linear *info_linear;
         struct perf_tool *tool = session->tool;
+        struct bpf_prog_info_node *info_node;
         struct bpf_prog_info *info;
         struct btf *btf = NULL;
         bool has_btf = false;
+        struct perf_env *env;
         u32 sub_prog_cnt, i;
         int err = 0;
         u64 arrays;
 
+        /*
+         * for perf-record and perf-report use header.env;
+         * otherwise, use global perf_env.
+         */
+        env = session->data ? &session->header.env : &perf_env;
+
         arrays = 1UL << BPF_PROG_INFO_JITED_KSYMS;
         arrays |= 1UL << BPF_PROG_INFO_JITED_FUNC_LENS;
         arrays |= 1UL << BPF_PROG_INFO_FUNC_INFO;
         arrays |= 1UL << BPF_PROG_INFO_PROG_TAGS;
+        arrays |= 1UL << BPF_PROG_INFO_JITED_INSNS;
+        arrays |= 1UL << BPF_PROG_INFO_LINE_INFO;
+        arrays |= 1UL << BPF_PROG_INFO_JITED_LINE_INFO;
 
         info_linear = bpf_program__get_prog_info_linear(fd, arrays);
         if (IS_ERR_OR_NULL(info_linear)) {
@@ -153,8 +165,8 @@ static int perf_event__synthesize_one_bpf_prog(struct perf_session *session,
                                                      machine, process);
         }
 
-        /* Synthesize PERF_RECORD_BPF_EVENT */
         if (!opts->no_bpf_event) {
+                /* Synthesize PERF_RECORD_BPF_EVENT */
                 *bpf_event = (struct bpf_event){
                         .header = {
                                 .type = PERF_RECORD_BPF_EVENT,
@@ -167,6 +179,22 @@ static int perf_event__synthesize_one_bpf_prog(struct perf_session *session,
                 memcpy(bpf_event->tag, info->tag, BPF_TAG_SIZE);
                 memset((void *)event + event->header.size, 0, machine->id_hdr_size);
                 event->header.size += machine->id_hdr_size;
+
+                /* save bpf_prog_info to env */
+                info_node = malloc(sizeof(struct bpf_prog_info_node));
+                if (!info_node) {
+                        err = -1;
+                        goto out;
+                }
+
+                info_node->info_linear = info_linear;
+                perf_env__insert_bpf_prog_info(env, info_node);
+                info_linear = NULL;
+
+                /*
+                 * process after saving bpf_prog_info to env, so that
+                 * required information is ready for look up
+                 */
                 err = perf_tool__process_synth_event(tool, event,
                                                      machine, process);
         }
diff --git a/tools/perf/util/bpf-event.h b/tools/perf/util/bpf-event.h
index 6698683612a7..fad932f7404f 100644
--- a/tools/perf/util/bpf-event.h
+++ b/tools/perf/util/bpf-event.h
@@ -3,14 +3,19 @@
 #define __PERF_BPF_EVENT_H
 
 #include <linux/compiler.h>
+#include <linux/rbtree.h>
 #include "event.h"
 
 struct machine;
 union perf_event;
 struct perf_sample;
-struct perf_tool;
 struct record_opts;
 
+struct bpf_prog_info_node {
+        struct bpf_prog_info_linear     *info_linear;
+        struct rb_node                  rb_node;
+};
+
 #ifdef HAVE_LIBBPF_SUPPORT
 int machine__process_bpf_event(struct machine *machine, union perf_event *event,
                                struct perf_sample *sample);
diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c
index 4c23779e271a..98cd36f0e317 100644
--- a/tools/perf/util/env.c
+++ b/tools/perf/util/env.c
@@ -3,15 +3,97 @@
 #include "env.h"
 #include "sane_ctype.h"
 #include "util.h"
+#include "bpf-event.h"
 #include <errno.h>
 #include <sys/utsname.h>
+#include <bpf/libbpf.h>
 
 struct perf_env perf_env;
 
+void perf_env__insert_bpf_prog_info(struct perf_env *env,
+                                    struct bpf_prog_info_node *info_node)
+{
+        __u32 prog_id = info_node->info_linear->info.id;
+        struct bpf_prog_info_node *node;
+        struct rb_node *parent = NULL;
+        struct rb_node **p;
+
+        down_write(&env->bpf_progs.lock);
+        p = &env->bpf_progs.infos.rb_node;
+
+        while (*p != NULL) {
+                parent = *p;
+                node = rb_entry(parent, struct bpf_prog_info_node, rb_node);
+                if (prog_id < node->info_linear->info.id) {
+                        p = &(*p)->rb_left;
+                } else if (prog_id > node->info_linear->info.id) {
+                        p = &(*p)->rb_right;
+                } else {
+                        pr_debug("duplicated bpf prog info %u\n", prog_id);
+                        goto out;
+                }
+        }
+
+        rb_link_node(&info_node->rb_node, parent, p);
+        rb_insert_color(&info_node->rb_node, &env->bpf_progs.infos);
+        env->bpf_progs.infos_cnt++;
+out:
+        up_write(&env->bpf_progs.lock);
+}
+
+struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env,
+                                                        __u32 prog_id)
+{
+        struct bpf_prog_info_node *node = NULL;
+        struct rb_node *n;
+
+        down_read(&env->bpf_progs.lock);
+        n = env->bpf_progs.infos.rb_node;
+
+        while (n) {
+                node = rb_entry(n, struct bpf_prog_info_node, rb_node);
+                if (prog_id < node->info_linear->info.id)
+                        n = n->rb_left;
+                else if (prog_id > node->info_linear->info.id)
+                        n = n->rb_right;
+                else
+                        break;
+        }
+
+        up_read(&env->bpf_progs.lock);
+        return node;
+}
+
+/* purge data in bpf_progs.infos tree */
+static void perf_env__purge_bpf(struct perf_env *env)
+{
+        struct rb_root *root;
+        struct rb_node *next;
+
+        down_write(&env->bpf_progs.lock);
+
+        root = &env->bpf_progs.infos;
+        next = rb_first(root);
+
+        while (next) {
+                struct bpf_prog_info_node *node;
+
+                node = rb_entry(next, struct bpf_prog_info_node, rb_node);
+                next = rb_next(&node->rb_node);
+                rb_erase(&node->rb_node, root);
+                free(node);
+        }
+
+        env->bpf_progs.infos_cnt = 0;
+
+        up_write(&env->bpf_progs.lock);
+}
+
 void perf_env__exit(struct perf_env *env)
 {
         int i;
 
+        perf_env__purge_bpf(env);
         zfree(&env->hostname);
         zfree(&env->os_release);
         zfree(&env->version);
@@ -38,6 +120,12 @@ void perf_env__exit(struct perf_env *env)
         zfree(&env->memory_nodes);
 }
 
+void perf_env__init(struct perf_env *env)
+{
+        env->bpf_progs.infos = RB_ROOT;
+        init_rwsem(&env->bpf_progs.lock);
+}
+
 int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[])
 {
         int i;
diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h
index d01b8355f4ca..24b11c564ba4 100644
--- a/tools/perf/util/env.h
+++ b/tools/perf/util/env.h
@@ -3,7 +3,9 @@
 #define __PERF_ENV_H
 
 #include <linux/types.h>
+#include <linux/rbtree.h>
 #include "cpumap.h"
+#include "rwsem.h"
 
 struct cpu_topology_map {
         int     socket_id;
@@ -64,8 +66,20 @@ struct perf_env {
         struct memory_node      *memory_nodes;
         unsigned long long       memory_bsize;
         u64                     clockid_res_ns;
+
+        /*
+         * bpf_info_lock protects bpf rbtrees. This is needed because the
+         * trees are accessed by different threads in perf-top
+         */
+        struct {
+                struct rw_semaphore     lock;
+                struct rb_root          infos;
+                u32                     infos_cnt;
+        } bpf_progs;
 };
 
+struct bpf_prog_info_node;
+
 extern struct perf_env perf_env;
 
 void perf_env__exit(struct perf_env *env);
@@ -80,4 +94,9 @@ const char *perf_env__arch(struct perf_env *env);
 const char *perf_env__raw_arch(struct perf_env *env);
 int perf_env__nr_cpus_avail(struct perf_env *env);
 
+void perf_env__init(struct perf_env *env);
+void perf_env__insert_bpf_prog_info(struct perf_env *env,
+                                    struct bpf_prog_info_node *info_node);
+struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env,
+                                                        __u32 prog_id);
 #endif /* __PERF_ENV_H */
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 0ec34227bd60..b17f1c9bc965 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -132,6 +132,7 @@ struct perf_session *perf_session__new(struct perf_data *data,
         ordered_events__init(&session->ordered_events,
                              ordered_events__deliver_event, NULL);
 
+        perf_env__init(&session->header.env);
         if (data) {
                 if (perf_data__open(data))
                         goto out_delete;