From patchwork Thu Oct 8 08:29:35 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Nan X-Patchwork-Id: 54630 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-wi0-f198.google.com (mail-wi0-f198.google.com [209.85.212.198]) by patches.linaro.org (Postfix) with ESMTPS id 6DCF122FF8 for ; Thu, 8 Oct 2015 08:32:49 +0000 (UTC) Received: by wisv5 with SMTP id v5sf6780193wis.0 for ; Thu, 08 Oct 2015 01:32:48 -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=xVq5pAY7r2wPuQubNwySawLOp6Ns/4fNR5mIvzdwyk0=; b=RGn9u3UZmm7Kl1YRWC6sl1vj+iL+0q9gfiZKxnLln8wzqjPK+XzvJHrN+EcRaR7wGq Ci9W1YN9rirblCoez9eF2IZ3/eSq2FCmoGkjQa1BCyj6P3Y0sOe5dKYEOyIeMV+pOVLB aXXolUvXdTVDwyg8mOxa+KPkfMZw0u2OE6nxCJrkhBcmmfHOCyKK/g3nGMiOG4iuKGrH VUKrlXAdb/HQEGXWCxerugtjHZTUn88166EcMT7y8liKg9+XbZ8xO43xSDldIR9D1BQZ NuikdJxxmE1IZW/xf/LCbMy9wN4Az4G4Ibk1VAsdfvGasEpYp2grVUivfJcdIzyJ1xO/ VdyA== X-Gm-Message-State: ALoCoQltpNanlBB557cRalgywYiGrh+OiPTOJ3C4zRf7wxNhuNmyBfodKtN6CANwZZ+C6+Qb+tE8 X-Received: by 10.194.109.233 with SMTP id hv9mr1123659wjb.1.1444293168712; Thu, 08 Oct 2015 01:32:48 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.25.20.230 with SMTP id 99ls158850lfu.32.gmail; Thu, 08 Oct 2015 01:32:48 -0700 (PDT) X-Received: by 10.25.32.131 with SMTP id g125mr1954651lfg.26.1444293168453; Thu, 08 Oct 2015 01:32:48 -0700 (PDT) Received: from mail-lb0-f179.google.com (mail-lb0-f179.google.com. [209.85.217.179]) by mx.google.com with ESMTPS id g18si28805667lfe.115.2015.10.08.01.32.48 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 08 Oct 2015 01:32:48 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.179 as permitted sender) client-ip=209.85.217.179; Received: by lbos8 with SMTP id s8so38216168lbo.0 for ; Thu, 08 Oct 2015 01:32:48 -0700 (PDT) X-Received: by 10.112.139.201 with SMTP id ra9mr2914303lbb.29.1444293168063; Thu, 08 Oct 2015 01:32:48 -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.59.35 with SMTP id w3csp438419lbq; Thu, 8 Oct 2015 01:32:46 -0700 (PDT) X-Received: by 10.68.137.35 with SMTP id qf3mr6649396pbb.89.1444293166860; Thu, 08 Oct 2015 01:32:46 -0700 (PDT) Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b10si64749913pbu.47.2015.10.08.01.32.46; Thu, 08 Oct 2015 01:32:46 -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 S1754226AbbJHIcn (ORCPT + 30 others); Thu, 8 Oct 2015 04:32:43 -0400 Received: from szxga02-in.huawei.com ([119.145.14.65]:50287 "EHLO szxga02-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754202AbbJHIcl (ORCPT ); Thu, 8 Oct 2015 04:32:41 -0400 Received: from 172.24.1.48 (EHLO szxeml427-hub.china.huawei.com) ([172.24.1.48]) by szxrg02-dlp.huawei.com (MOS 4.3.7-GA FastPath queued) with ESMTP id CTW16131; Thu, 08 Oct 2015 16:30:00 +0800 (CST) Received: from linux-4hy3.site (10.107.193.248) by szxeml427-hub.china.huawei.com (10.82.67.182) with Microsoft SMTP Server id 14.3.235.1; Thu, 8 Oct 2015 16:29:36 +0800 From: Wang Nan To: CC: , , , Wang Nan , He Kuang , "Alexei Starovoitov" , Brendan Gregg , Daniel Borkmann , David Ahern , Jiri Olsa , Kaixu Xia , "Masami Hiramatsu" , Namhyung Kim , Paul Mackerras , Peter Zijlstra Subject: [PATCH 13/22] bpf tools: Load a program with different instances using preprocessor Date: Thu, 8 Oct 2015 08:29:35 +0000 Message-ID: <1444292984-13135-14-git-send-email-wangnan0@huawei.com> X-Mailer: git-send-email 1.8.3.4 In-Reply-To: <1444292984-13135-1-git-send-email-wangnan0@huawei.com> References: <1444292984-13135-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.179 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: , In this patch, caller of libbpf is able to control the loaded programs by installing a preprocessor callback for a BPF program. With preprocessor, different instances can be created from one BPF program. This patch will be used by perf to generate different prologue for different 'struct probe_trace_event' instances matched by one 'struct perf_probe_event'. bpf_program__set_prep() is added to support this feature. Caller should pass libbpf the number of instances should be created and a preprocessor function which will be called when doing real loading. The callback should return instructions arrays for each instances. fd field in bpf_programs is replaced by instance, which has an nr field and fds array. bpf_program__nth_fd() is introduced for read fd of instances. Old interface bpf_program__fd() is reimplemented by returning the first fd. Signed-off-by: Wang Nan Signed-off-by: He Kuang 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/ebpf-6yw9eg0ej3l4jnqhinngkw86@git.kernel.org --- tools/lib/bpf/libbpf.c | 143 +++++++++++++++++++++++++++++++++++++++++++++---- tools/lib/bpf/libbpf.h | 22 ++++++++ 2 files changed, 156 insertions(+), 9 deletions(-) diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 4252fc2..6a07b26 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -98,7 +98,11 @@ struct bpf_program { } *reloc_desc; int nr_reloc; - int fd; + struct { + int nr; + int *fds; + } instance; + bpf_program_prep_t preprocessor; struct bpf_object *obj; void *priv; @@ -152,10 +156,24 @@ struct bpf_object { static void bpf_program__unload(struct bpf_program *prog) { + int i; + if (!prog) return; - zclose(prog->fd); + /* + * If the object is opened but the program is never loaded, + * it is possible that prog->instance.nr == -1. + */ + if (prog->instance.nr > 0) { + for (i = 0; i < prog->instance.nr; i++) + zclose(prog->instance.fds[i]); + } else if (prog->instance.nr != -1) + pr_warning("Internal error: instance.nr is %d\n", + prog->instance.nr); + + prog->instance.nr = -1; + zfree(&prog->instance.fds); } static void bpf_program__exit(struct bpf_program *prog) @@ -206,7 +224,8 @@ bpf_program__init(void *data, size_t size, char *name, int idx, memcpy(prog->insns, data, prog->insns_cnt * sizeof(struct bpf_insn)); prog->idx = idx; - prog->fd = -1; + prog->instance.fds = NULL; + prog->instance.nr = -1; return 0; errout: @@ -795,13 +814,71 @@ static int bpf_program__load(struct bpf_program *prog, char *license, u32 kern_version) { - int err, fd; + int err = 0, fd, i; + + if (prog->instance.nr < 0 || !prog->instance.fds) { + if (prog->preprocessor) { + pr_warning("Internal error: can't load program '%s'\n", + prog->section_name); + return -EINVAL; + } + + prog->instance.fds = malloc(sizeof(int)); + if (!prog->instance.fds) { + pr_warning("No enough memory for fds\n"); + return -ENOMEM; + } + prog->instance.nr = 1; + prog->instance.fds[0] = -1; + } + + if (!prog->preprocessor) { + if (prog->instance.nr != 1) + pr_warning("Program '%s' inconsistent: nr(%d) not 1\n", + prog->section_name, prog->instance.nr); - err = load_program(prog->insns, prog->insns_cnt, - license, kern_version, &fd); - if (!err) - prog->fd = fd; + err = load_program(prog->insns, prog->insns_cnt, + license, kern_version, &fd); + if (!err) + prog->instance.fds[0] = fd; + goto out; + } + + for (i = 0; i < prog->instance.nr; i++) { + struct bpf_prog_prep_result result; + bpf_program_prep_t preprocessor = prog->preprocessor; + + bzero(&result, sizeof(result)); + err = preprocessor(prog, i, prog->insns, + prog->insns_cnt, &result); + if (err) { + pr_warning("Preprocessing %dth instance of program '%s' failed\n", + i, prog->section_name); + goto out; + } + + if (!result.new_insn_ptr || !result.new_insn_cnt) { + pr_debug("Skip loading %dth instance of program '%s'\n", + i, prog->section_name); + prog->instance.fds[i] = -1; + continue; + } + + err = load_program(result.new_insn_ptr, + result.new_insn_cnt, + license, kern_version, &fd); + + if (err) { + pr_warning("Loading %dth instance of program '%s' failed\n", + i, prog->section_name); + goto out; + } + if (result.pfd) + *result.pfd = fd; + prog->instance.fds[i] = fd; + } +out: if (err) pr_warning("failed to load program '%s'\n", prog->section_name); @@ -1052,5 +1129,53 @@ const char *bpf_program__title(struct bpf_program *prog, bool dup) int bpf_program__fd(struct bpf_program *prog) { - return prog->fd; + return bpf_program__nth_fd(prog, 0); +} + +int bpf_program__set_prep(struct bpf_program *prog, int nr_instance, + bpf_program_prep_t prep) +{ + int *instance_fds; + + if (nr_instance <= 0 || !prep) + return -EINVAL; + + if (prog->instance.nr > 0 || prog->instance.fds) { + pr_warning("Can't set pre-processor after loading\n"); + return -EINVAL; + } + + instance_fds = malloc(sizeof(int) * nr_instance); + if (!instance_fds) { + pr_warning("alloc memory failed for instance of fds\n"); + return -ENOMEM; + } + + /* fill all fd with -1 */ + memset(instance_fds, 0xff, sizeof(int) * nr_instance); + + prog->instance.nr = nr_instance; + prog->instance.fds = instance_fds; + prog->preprocessor = prep; + return 0; +} + +int bpf_program__nth_fd(struct bpf_program *prog, int n) +{ + int fd; + + if (n >= prog->instance.nr || n < 0) { + pr_warning("Can't get the %dth fd from program %s: only %d instances\n", + n, prog->section_name, prog->instance.nr); + return -EINVAL; + } + + fd = prog->instance.fds[n]; + if (fd < 0) { + pr_warning("%dth instance of program '%s' is invalid\n", + n, prog->section_name); + return -ENOENT; + } + + return fd; } diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h index f16170c..d82b89e 100644 --- a/tools/lib/bpf/libbpf.h +++ b/tools/lib/bpf/libbpf.h @@ -67,6 +67,28 @@ const char *bpf_program__title(struct bpf_program *prog, bool dup); int bpf_program__fd(struct bpf_program *prog); +struct bpf_insn; +struct bpf_prog_prep_result { + /* + * If not NULL, load new instruction array. + * If set to NULL, don't load this instance. + */ + struct bpf_insn *new_insn_ptr; + int new_insn_cnt; + + /* If not NULL, result fd is set to it */ + int *pfd; +}; + +typedef int (*bpf_program_prep_t)(struct bpf_program *, int n, + struct bpf_insn *, int insn_cnt, + struct bpf_prog_prep_result *res); + +int bpf_program__set_prep(struct bpf_program *prog, int nr_instance, + bpf_program_prep_t prep); + +int bpf_program__nth_fd(struct bpf_program *prog, int n); + /* * We don't need __attribute__((packed)) now since it is * unnecessary for 'bpf_map_def' because they are all aligned.