From: Wang Nan <wangnan0@huawei.com>
To: <acme@kernel.org>, <ast@plumgrid.com>, <brendan.d.gregg@gmail.com>,
        <daniel@iogearbox.net>, <namhyung@kernel.org>,
        <masami.hiramatsu.pt@hitachi.com>, <paulus@samba.org>,
        <a.p.zijlstra@chello.nl>, <mingo@redhat.com>, <jolsa@kernel.org>,
        <dsahern@gmail.com>
CC: <linux-kernel@vger.kernel.org>, <lizefan@huawei.com>, <hekuang@huawei.com>,
        <xiakaixu@huawei.com>, <pi3orama@163.com>
Subject: [RFC PATCH v10 46/50] perf tools: Generate prologue for BPF programs
Date: Wed, 1 Jul 2015 02:14:34 +0000
Message-ID: <1435716878-189507-47-git-send-email-wangnan0@huawei.com>
In-Reply-To: <1435716878-189507-1-git-send-email-wangnan0@huawei.com>
References: <1435716878-189507-1-git-send-email-wangnan0@huawei.com>
MIME-Version: 1.0
Content-Type: text/plain
Sender: linux-kernel-owner@vger.kernel.org
Content-Length: 5120
Lines: 209

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 none of 'struct perf_probe_event' a program
will attach has at least one 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 <wangnan0@huawei.com>
---
 tools/perf/util/bpf-loader.c | 133 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 131 insertions(+), 2 deletions(-)

diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c
index 197e4a3..24a55b9 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 <linux/bpf.h>
 #include <bpf/libbpf.h>
 #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"
@@ -53,6 +55,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
@@ -63,6 +67,7 @@ bpf_prog_priv__clear(struct bpf_program *prog __maybe_unused,
 
 	if (priv->pev)
 		clear_perf_probe_event(priv->pev);
+	zfree(&priv->insns_buf);
 	free(priv);
 }
 
@@ -223,10 +228,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;
@@ -245,7 +349,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)
@@ -291,7 +415,12 @@ int bpf__foreach_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

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/