From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753232AbbFXMef (ORCPT ); Wed, 24 Jun 2015 08:34:35 -0400 Received: from szxga01-in.huawei.com ([58.251.152.64]:21112 "EHLO szxga01-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753074AbbFXMdl (ORCPT ); Wed, 24 Jun 2015 08:33:41 -0400 From: Wang Nan To: , , , , , , , , , , CC: , , , , Subject: [RFC PATCH v8 47/49] perf tools: Generate prologue for BPF programs Date: Wed, 24 Jun 2015 12:31:51 +0000 Message-ID: <1435149113-51142-48-git-send-email-wangnan0@huawei.com> X-Mailer: git-send-email 1.8.3.4 In-Reply-To: <1435149113-51142-1-git-send-email-wangnan0@huawei.com> References: <1435149113-51142-1-git-send-email-wangnan0@huawei.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [10.107.197.200] X-CFilter-Loop: Reflected Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch generates prologue for each 'struct probe_trace_event' for fetching arguments for BPF programs. After bpf__probe(), iterate over each programs to check whether prologue is required. If non of tev have argument, simply skip preprocessor hooking. For those who prologue is required, calls bpf__gen_prologue() and paste original instruction after prologue. Signed-off-by: Wang Nan --- tools/perf/util/bpf-loader.c | 131 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 129 insertions(+), 2 deletions(-) diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c index 8812e24..581638e 100644 --- a/tools/perf/util/bpf-loader.c +++ b/tools/perf/util/bpf-loader.c @@ -5,10 +5,12 @@ * Copyright (C) 2015 Huawei Inc. */ +#include #include #include "perf.h" #include "debug.h" #include "bpf-loader.h" +#include "bpf-prologue.h" #include "llvm-utils.h" #include "probe-event.h" #include "probe-finder.h" @@ -52,6 +54,8 @@ alloc_perf_probe_event(void) struct bpf_prog_priv { struct perf_probe_event *pev; + bool need_prologue; + struct bpf_insn *insns_buf; }; static void @@ -61,6 +65,7 @@ bpf_prog_priv__clear(struct bpf_program *prog __maybe_unused, struct bpf_prog_priv *priv = _priv; if (priv->pev) clear_perf_probe_event(priv->pev); + zfree(&priv->insns_buf); free(priv); } @@ -221,10 +226,109 @@ int bpf__unprobe(void) return ret < 0 ? ret : 0; } +static int +preproc_gen_prologue(struct bpf_program *prog, int n, + struct bpf_insn *orig_insns, int orig_insns_cnt, + struct bpf_prog_prep_result *res) +{ + struct probe_trace_event *tev; + struct perf_probe_event *pev; + struct bpf_prog_priv *priv; + struct bpf_insn *buf; + size_t prologue_cnt = 0; + int err; + + err = bpf_program__get_private(prog, (void **)&priv); + if (err || !priv) + goto errout; + + pev = priv->pev; + + if (n < 0 || n >= pev->ntevs) + goto errout; + + tev = &pev->tevs[n]; + + buf = priv->insns_buf; + err = bpf__gen_prologue(tev->args, tev->nargs, + buf, &prologue_cnt, + BPF_MAXINSNS - orig_insns_cnt); + if (err) { + const char *title; + + err = bpf_program__get_title(prog, &title, false); + if (err) + title = "??"; + + pr_err("Failed to generate prologue for program %s\n", + title); + return err; + } + + memcpy(&buf[prologue_cnt], orig_insns, + sizeof(struct bpf_insn) * orig_insns_cnt); + + res->new_insn_ptr = buf; + res->new_insn_cnt = prologue_cnt + orig_insns_cnt; + res->pfd = NULL; + return 0; + +errout: + pr_err("Internal error in preproc_gen_prologue\n"); + return -EINVAL; +} + +static int hook_load_preprocessor(struct bpf_program *prog) +{ + struct perf_probe_event *pev; + struct bpf_prog_priv *priv; + bool need_prologue = false; + int err, i; + + err = bpf_program__get_private(prog, (void **)&priv); + if (err || !priv) { + pr_err("Internal error when hook preprocessor\n"); + return -EINVAL; + } + + pev = priv->pev; + for (i = 0; i < pev->ntevs; i++) { + struct probe_trace_event *tev = &pev->tevs[i]; + + if (tev->nargs > 0) { + need_prologue = true; + break; + } + } + + /* + * Since all tev doesn't have argument, we don't need generate + * prologue. + */ + if (!need_prologue) { + priv->need_prologue = false; + return 0; + } + + priv->need_prologue = true; + priv->insns_buf = malloc(sizeof(struct bpf_insn) * + BPF_MAXINSNS); + if (!priv->insns_buf) { + pr_err("No enough memory: alloc insns_buf failed\n"); + return -ENOMEM; + } + + err = bpf_program__set_prep(prog, pev->ntevs, + preproc_gen_prologue); + return err; +} + int bpf__probe(void) { int err; bool old_silent = probe_conf.silent; + struct bpf_object *obj, *tmp; + struct bpf_program *prog; if (nr_probe_events <= 0) return 0; @@ -243,7 +347,27 @@ int bpf__probe(void) else is_probing = true; - return err < 0 ? err : 0; + err = err < 0 ? err : 0; + if (err) + return err; + + /* + * After probing, let's consider prologue, which + * add program fetcher to BPF programs. + * + * hook_load_preprocessorr() hooks pre-processor to bpf_program, + * let it generate prologue dynamically during loading. + */ + + bpf_object__for_each(obj, tmp) { + bpf_object__for_each_program(prog, obj) { + err = hook_load_preprocessor(prog); + if (err) + return err; + } + } + + return err; } int bpf__load(void) @@ -290,7 +414,10 @@ bpf__for_each_tev(bpf_prog_iter_callback_t func, void *arg) for (i = 0; i < pev->ntevs; i++) { tev = &pev->tevs[i]; - err = bpf_program__get_fd(prog, &fd); + if (priv->need_prologue) + err = bpf_program__get_nth_fd(prog, i, &fd); + else + err = bpf_program__get_fd(prog, &fd); if (err || fd < 0) { pr_err("bpf: failed to get file descriptor\n"); -- 1.8.3.4