From patchwork Sun Sep 6 07:13:37 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Nan X-Patchwork-Id: 53182 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-la0-f72.google.com (mail-la0-f72.google.com [209.85.215.72]) by patches.linaro.org (Postfix) with ESMTPS id 4CCED22B05 for ; Sun, 6 Sep 2015 07:18:33 +0000 (UTC) Received: by lagj9 with SMTP id j9sf19069918lag.0 for ; Sun, 06 Sep 2015 00:18:32 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-type:sender:precedence :list-id:x-original-sender:x-original-authentication-results :mailing-list:list-post:list-help:list-archive:list-unsubscribe; bh=E/G3vbqnCj9siI9KE890sFdoSQuCMMwvJPwGHWlW5rw=; b=TsInGR+da69niH2RpVtdGp9WdOjk8hwPlXxJxvhvX4KEbBFCtk1i0cN1Xwb52fl6Ox rxZdOOAAdqaf9sdwi0dc8OyWAy7DHEnrmP7d/EL8L7/Wlh3eJNui0i/ubGRB4T3ybD8V 4isedUoKYkqxjnAmeM+KNsOiXf1z80ZaWoc3fOwlqDGL4NKkdmsPolK0toZdZrNw0pXk FHwoeOUWP577ZCe8mxhKB1dHQQ3yfYu1oUPOErwVnjZkSmsi60o//uaN1SJqVd4Z4th6 FHsYDXzqNKc3Evd45IpzbO4lK3DBh+7/a+116GCF+7M05f34bJbqN/mJAm70K5oFAFBW nxIA== X-Gm-Message-State: ALoCoQlBPXdt49lt3UWgSkd700APeBvV32BC6zhZZuC0SLeL1OCSZHhV0SrkBiwG5zPeCyqweGTu X-Received: by 10.112.138.2 with SMTP id qm2mr3300257lbb.19.1441523912236; Sun, 06 Sep 2015 00:18:32 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.1.73 with SMTP id 9ls420492lak.17.gmail; Sun, 06 Sep 2015 00:18:31 -0700 (PDT) X-Received: by 10.152.25.225 with SMTP id f1mr3821384lag.52.1441523911929; Sun, 06 Sep 2015 00:18:31 -0700 (PDT) Received: from mail-lb0-f180.google.com (mail-lb0-f180.google.com. [209.85.217.180]) by mx.google.com with ESMTPS id b8si7227546lbg.101.2015.09.06.00.18.31 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sun, 06 Sep 2015 00:18:31 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.180 as permitted sender) client-ip=209.85.217.180; Received: by lbbmp1 with SMTP id mp1so27039978lbb.1 for ; Sun, 06 Sep 2015 00:18:31 -0700 (PDT) X-Received: by 10.112.166.106 with SMTP id zf10mr11632290lbb.36.1441523911747; Sun, 06 Sep 2015 00:18:31 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.164.42 with SMTP id yn10csp844528lbb; Sun, 6 Sep 2015 00:18:30 -0700 (PDT) X-Received: by 10.66.254.65 with SMTP id ag1mr29595621pad.134.1441523910537; Sun, 06 Sep 2015 00:18:30 -0700 (PDT) Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id gl11si13730730pbd.183.2015.09.06.00.18.29; Sun, 06 Sep 2015 00:18:30 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752932AbbIFHSU (ORCPT + 28 others); Sun, 6 Sep 2015 03:18:20 -0400 Received: from szxga01-in.huawei.com ([58.251.152.64]:7739 "EHLO szxga01-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751476AbbIFHOp (ORCPT ); Sun, 6 Sep 2015 03:14:45 -0400 Received: from 172.24.1.48 (EHLO SZXEML423-HUB.china.huawei.com) ([172.24.1.48]) by szxrg01-dlp.huawei.com (MOS 4.3.7-GA FastPath queued) with ESMTP id CUK94076; Sun, 06 Sep 2015 15:14:26 +0800 (CST) Received: from linux-4hy3.site (10.107.193.248) by SZXEML423-HUB.china.huawei.com (10.82.67.154) with Microsoft SMTP Server id 14.3.235.1; Sun, 6 Sep 2015 15:14:14 +0800 From: Wang Nan To: , , , CC: , , , , , , , , , , , Subject: [PATCH 21/27] perf tools: Generate prologue for BPF programs Date: Sun, 6 Sep 2015 07:13:37 +0000 Message-ID: <1441523623-152703-22-git-send-email-wangnan0@huawei.com> X-Mailer: git-send-email 1.8.3.4 In-Reply-To: <1441523623-152703-1-git-send-email-wangnan0@huawei.com> References: <1441523623-152703-1-git-send-email-wangnan0@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.107.193.248] X-CFilter-Loop: Reflected Sender: linux-kernel-owner@vger.kernel.org Precedence: list List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: wangnan0@huawei.com X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.180 as permitted sender) smtp.mailfrom=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 List-Post: , List-Help: , List-Archive: List-Unsubscribe: , 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 to 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 Cc: Alexei Starovoitov Cc: Brendan Gregg Cc: Daniel Borkmann Cc: David Ahern Cc: He Kuang Cc: Jiri Olsa Cc: Kaixu Xia Cc: Masami Hiramatsu Cc: Namhyung Kim Cc: Paul Mackerras Cc: Peter Zijlstra Cc: Zefan Li Cc: pi3orama@163.com Cc: Arnaldo Carvalho de Melo Link: http://lkml.kernel.org/n/1436445342-1402-36-git-send-email-wangnan0@huawei.com --- tools/perf/util/bpf-loader.c | 120 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 119 insertions(+), 1 deletion(-) diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c index 1994552..d3d40f3 100644 --- a/tools/perf/util/bpf-loader.c +++ b/tools/perf/util/bpf-loader.c @@ -5,10 +5,13 @@ * 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" #include "llvm-utils.h" @@ -42,6 +45,8 @@ struct bpf_prog_priv { struct perf_probe_event *ppev; struct perf_probe_event pev; }; + bool need_prologue; + struct bpf_insn *insns_buf; }; static void @@ -65,6 +70,7 @@ bpf_prog_priv__clear(struct bpf_program *prog __maybe_unused, clear_perf_probe_event(&priv->pev); } + zfree(&priv->insns_buf); free(priv); } @@ -248,6 +254,103 @@ 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 || !priv->pev_ready) + 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; + + title = bpf_program__title(prog, false); + if (!title) + title = "??"; + + pr_debug("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_debug("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_debug("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_debug("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, nr_events = 0; @@ -311,6 +414,17 @@ int bpf__probe(void) err = sync_bpf_program_pev(prog); if (err) goto out; + /* + * After probing, let's consider prologue, which + * adds program fetcher to BPF programs. + * + * hook_load_preprocessorr() hooks pre-processor + * to bpf_program, let it generate prologue + * dynamically during loading. + */ + err = hook_load_preprocessor(prog); + if (err) + goto out; } } out: @@ -375,7 +489,11 @@ int bpf__foreach_tev(bpf_prog_iter_callback_t func, void *arg) for (i = 0; i < pev->ntevs; i++) { tev = &pev->tevs[i]; - fd = bpf_program__fd(prog); + if (priv->need_prologue) + fd = bpf_program__nth_fd(prog, i); + else + fd = bpf_program__fd(prog); + if (fd < 0) { pr_debug("bpf: failed to get file descriptor\n"); return fd;