From nobody Sun Feb 8 05:28:44 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5783A1DE2A7; Wed, 30 Apr 2025 06:06:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745993217; cv=none; b=E7oKQytEOl5eBQ/iPiMECBMpmI7qUxn/3xB0+q+p/PR/RrTrWbS22MqnP85tMv7/IshmeYIBmFXEenyD9YzikGvz4xj1/9KgocKGrssFjyVqhqbrJ+ZcwV4JU0xCgGOyMXGmv+3zhwhOO+AepHd+aWdaWzfwphf/POO39wUpV0M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745993217; c=relaxed/simple; bh=Qa2orF1FmtuhmsUpgkpDzS8EP0w35oFtgPbKJyYW480=; h=From:To:Cc:Subject:Date:Message-ID:MIME-Version; b=s962vHgwxrULEJASURN870ra62sbDBzVobUcDTQi18kOuWN+JRe6ypAiWXiucu0Mhh/lt9gh4r4tLeAlE+EzI51WnnxxKVyFNJCDrq1QBt9bv5FZsB7mT+P/xQJnege19bBkC7Uw9RX/mSqcwFJ1tVZ/XLi7ooeFkruSieBuyvU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=lTOnDWY+; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="lTOnDWY+" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1EB60C4CEE9; Wed, 30 Apr 2025 06:06:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1745993216; bh=Qa2orF1FmtuhmsUpgkpDzS8EP0w35oFtgPbKJyYW480=; h=From:To:Cc:Subject:Date:From; b=lTOnDWY+TRZahlVRdKhWnGddm0YoGYioDcsvll5e9pvAtV2qJyB2maGswgY0AZVpr 6/UijoJPOON2znAop86MNUDxzosf3ymWTpwfnRYoF121qqmmPjY+498NGJHSQxWqrK xKCDqKNabwqpNx8JRaz7RMqdw02cnG/1C7J8CanJEMJEHrOeKK3ZUWJzguhrL6Kx9Q HhV5WA6HZhPMrdyxzKzJG/PiFiMDTrJaog9r5f5XX491Zqir2nqxkiB8+sKuwWEk0Z om+vomclzdn+D+sedwGuWPYQNdBIJG7fjW9K6Lqakzg02sgGW6utJFhalihAgyg0yh dgcMl4xHVXgoA== From: Namhyung Kim To: Arnaldo Carvalho de Melo , Ian Rogers , Kan Liang Cc: Jiri Olsa , Adrian Hunter , Peter Zijlstra , Ingo Molnar , LKML , linux-perf-users@vger.kernel.org, Song Liu , bpf@vger.kernel.org, Howard Chu Subject: [PATCH] perf trace: Split BPF skel code to util/trace_augment.c Date: Tue, 29 Apr 2025 23:06:16 -0700 Message-ID: <20250430060616.18576-1-namhyung@kernel.org> X-Mailer: git-send-email 2.49.0 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" And make builtin-trace.c less conditional. Dummy functions will be called when BUILD_BPF_SKEL=3D0 is used. This makes the builtin-trace.c slightly smaller and simpler by removing the skeleton and its helpers. The conditional guard of trace__init_syscalls_bpf_prog_array_maps() is changed from the HAVE_BPF_SKEL to HAVE_LIBBPF_SUPPORT as it doesn't have a skeleton in the code directly. And a dummy function is added so that it can be called unconditionally. The function will succeed only if the both conditions are true. Do not include trace_augment.h from the BPF code and move the definition of TRACE_AUG_MAX_BUF to the BPF directly. Cc: Howard Chu Signed-off-by: Namhyung Kim Reviewed-by: Howard Chu --- tools/perf/builtin-trace.c | 187 +++++------------- tools/perf/util/Build | 1 + .../bpf_skel/augmented_raw_syscalls.bpf.c | 3 +- tools/perf/util/trace_augment.c | 143 ++++++++++++++ tools/perf/util/trace_augment.h | 62 +++++- 5 files changed, 255 insertions(+), 141 deletions(-) create mode 100644 tools/perf/util/trace_augment.c diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c index 809b4d5b0a8a4ddc..3f3f6fadef0a128f 100644 --- a/tools/perf/builtin-trace.c +++ b/tools/perf/builtin-trace.c @@ -20,9 +20,6 @@ #include #include #include -#ifdef HAVE_BPF_SKEL -#include "bpf_skel/augmented_raw_syscalls.skel.h" -#endif #endif #include "util/bpf_map.h" #include "util/rlimit.h" @@ -155,9 +152,6 @@ struct trace { *bpf_output; } events; } syscalls; -#ifdef HAVE_BPF_SKEL - struct augmented_raw_syscalls_bpf *skel; -#endif #ifdef HAVE_LIBBPF_SUPPORT struct btf *btf; #endif @@ -3699,7 +3693,10 @@ static int trace__set_ev_qualifier_tp_filter(struct = trace *trace) goto out; } =20 -#ifdef HAVE_BPF_SKEL +#ifdef HAVE_LIBBPF_SUPPORT + +static struct bpf_program *unaugmented_prog; + static int syscall_arg_fmt__cache_btf_struct(struct syscall_arg_fmt *arg_f= mt, struct btf *btf, char *type) { int id; @@ -3717,26 +3714,8 @@ static int syscall_arg_fmt__cache_btf_struct(struct = syscall_arg_fmt *arg_fmt, st return 0; } =20 -static struct bpf_program *trace__find_bpf_program_by_title(struct trace *= trace, const char *name) -{ - struct bpf_program *pos, *prog =3D NULL; - const char *sec_name; - - if (trace->skel->obj =3D=3D NULL) - return NULL; - - bpf_object__for_each_program(pos, trace->skel->obj) { - sec_name =3D bpf_program__section_name(pos); - if (sec_name && !strcmp(sec_name, name)) { - prog =3D pos; - break; - } - } - - return prog; -} - -static struct bpf_program *trace__find_syscall_bpf_prog(struct trace *trac= e, struct syscall *sc, +static struct bpf_program *trace__find_syscall_bpf_prog(struct trace *trac= e __maybe_unused, + struct syscall *sc, const char *prog_name, const char *type) { struct bpf_program *prog; @@ -3744,19 +3723,19 @@ static struct bpf_program *trace__find_syscall_bpf_= prog(struct trace *trace, str if (prog_name =3D=3D NULL) { char default_prog_name[256]; scnprintf(default_prog_name, sizeof(default_prog_name), "tp/syscalls/sys= _%s_%s", type, sc->name); - prog =3D trace__find_bpf_program_by_title(trace, default_prog_name); + prog =3D augmented_syscalls__find_by_title(default_prog_name); if (prog !=3D NULL) goto out_found; if (sc->fmt && sc->fmt->alias) { scnprintf(default_prog_name, sizeof(default_prog_name), "tp/syscalls/sy= s_%s_%s", type, sc->fmt->alias); - prog =3D trace__find_bpf_program_by_title(trace, default_prog_name); + prog =3D augmented_syscalls__find_by_title(default_prog_name); if (prog !=3D NULL) goto out_found; } goto out_unaugmented; } =20 - prog =3D trace__find_bpf_program_by_title(trace, prog_name); + prog =3D augmented_syscalls__find_by_title(prog_name); =20 if (prog !=3D NULL) { out_found: @@ -3766,7 +3745,7 @@ static struct bpf_program *trace__find_syscall_bpf_pr= og(struct trace *trace, str pr_debug("Couldn't find BPF prog \"%s\" to associate with syscalls:sys_%s= _%s, not augmenting it\n", prog_name, type, sc->name); out_unaugmented: - return trace->skel->progs.syscall_unaugmented; + return unaugmented_prog; } =20 static void trace__init_syscall_bpf_progs(struct trace *trace, int e_machi= ne, int id) @@ -3783,13 +3762,13 @@ static void trace__init_syscall_bpf_progs(struct tr= ace *trace, int e_machine, in static int trace__bpf_prog_sys_enter_fd(struct trace *trace, int e_machine= , int id) { struct syscall *sc =3D trace__syscall_info(trace, NULL, e_machine, id); - return sc ? bpf_program__fd(sc->bpf_prog.sys_enter) : bpf_program__fd(tra= ce->skel->progs.syscall_unaugmented); + return sc ? bpf_program__fd(sc->bpf_prog.sys_enter) : bpf_program__fd(una= ugmented_prog); } =20 static int trace__bpf_prog_sys_exit_fd(struct trace *trace, int e_machine,= int id) { struct syscall *sc =3D trace__syscall_info(trace, NULL, e_machine, id); - return sc ? bpf_program__fd(sc->bpf_prog.sys_exit) : bpf_program__fd(trac= e->skel->progs.syscall_unaugmented); + return sc ? bpf_program__fd(sc->bpf_prog.sys_exit) : bpf_program__fd(unau= gmented_prog); } =20 static int trace__bpf_sys_enter_beauty_map(struct trace *trace, int e_mach= ine, int key, unsigned int *beauty_array) @@ -3899,7 +3878,7 @@ static struct bpf_program *trace__find_usable_bpf_pro= g_entry(struct trace *trace bool is_candidate =3D false; =20 if (pair =3D=3D NULL || pair->id =3D=3D sc->id || - pair->bpf_prog.sys_enter =3D=3D trace->skel->progs.syscall_unaugment= ed) + pair->bpf_prog.sys_enter =3D=3D unaugmented_prog) continue; =20 for (field =3D sc->args, candidate_field =3D pair->args; @@ -3965,7 +3944,7 @@ static struct bpf_program *trace__find_usable_bpf_pro= g_entry(struct trace *trace */ if (pair_prog =3D=3D NULL) { pair_prog =3D trace__find_syscall_bpf_prog(trace, pair, pair->fmt ? pai= r->fmt->bpf_prog_name.sys_enter : NULL, "enter"); - if (pair_prog =3D=3D trace->skel->progs.syscall_unaugmented) + if (pair_prog =3D=3D unaugmented_prog) goto next_candidate; } =20 @@ -3981,12 +3960,17 @@ static struct bpf_program *trace__find_usable_bpf_p= rog_entry(struct trace *trace =20 static int trace__init_syscalls_bpf_prog_array_maps(struct trace *trace, i= nt e_machine) { - int map_enter_fd =3D bpf_map__fd(trace->skel->maps.syscalls_sys_enter); - int map_exit_fd =3D bpf_map__fd(trace->skel->maps.syscalls_sys_exit); - int beauty_map_fd =3D bpf_map__fd(trace->skel->maps.beauty_map_enter); + int map_enter_fd; + int map_exit_fd; + int beauty_map_fd; int err =3D 0; unsigned int beauty_array[6]; =20 + if (augmented_syscalls__get_map_fds(&map_enter_fd, &map_exit_fd, &beauty_= map_fd) < 0) + return -1; + + unaugmented_prog =3D augmented_syscalls__unaugmented(); + for (int i =3D 0, num_idx =3D syscalltbl__num_idx(e_machine); i < num_idx= ; ++i) { int prog_fd, key =3D syscalltbl__id_at_idx(e_machine, i); =20 @@ -4056,7 +4040,7 @@ static int trace__init_syscalls_bpf_prog_array_maps(s= truct trace *trace, int e_m * For now we're just reusing the sys_enter prog, and if it * already has an augmenter, we don't need to find one. */ - if (sc->bpf_prog.sys_enter !=3D trace->skel->progs.syscall_unaugmented) + if (sc->bpf_prog.sys_enter !=3D unaugmented_prog) continue; =20 /* @@ -4081,7 +4065,13 @@ static int trace__init_syscalls_bpf_prog_array_maps(= struct trace *trace, int e_m =20 return err; } -#endif // HAVE_BPF_SKEL +#else // !HAVE_LIBBPF_SUPPORT +static int trace__init_syscalls_bpf_prog_array_maps(struct trace *trace __= maybe_unused, + int e_machine __maybe_unused) +{ + return -1; +} +#endif // HAVE_LIBBPF_SUPPORT =20 static int trace__set_ev_qualifier_filter(struct trace *trace) { @@ -4090,24 +4080,6 @@ static int trace__set_ev_qualifier_filter(struct tra= ce *trace) return 0; } =20 -static int bpf_map__set_filter_pids(struct bpf_map *map __maybe_unused, - size_t npids __maybe_unused, pid_t *pids __maybe_unused) -{ - int err =3D 0; -#ifdef HAVE_LIBBPF_SUPPORT - bool value =3D true; - int map_fd =3D bpf_map__fd(map); - size_t i; - - for (i =3D 0; i < npids; ++i) { - err =3D bpf_map_update_elem(map_fd, &pids[i], &value, BPF_ANY); - if (err) - break; - } -#endif - return err; -} - static int trace__set_filter_loop_pids(struct trace *trace) { unsigned int nr =3D 1, err; @@ -4133,8 +4105,8 @@ static int trace__set_filter_loop_pids(struct trace *= trace) } =20 err =3D evlist__append_tp_filter_pids(trace->evlist, nr, pids); - if (!err && trace->filter_pids.map) - err =3D bpf_map__set_filter_pids(trace->filter_pids.map, nr, pids); + if (!err) + err =3D augmented_syscalls__set_filter_pids(nr, pids); =20 return err; } @@ -4151,8 +4123,8 @@ static int trace__set_filter_pids(struct trace *trace) if (trace->filter_pids.nr > 0) { err =3D evlist__append_tp_filter_pids(trace->evlist, trace->filter_pids.= nr, trace->filter_pids.entries); - if (!err && trace->filter_pids.map) { - err =3D bpf_map__set_filter_pids(trace->filter_pids.map, trace->filter_= pids.nr, + if (!err) { + err =3D augmented_syscalls__set_filter_pids(trace->filter_pids.nr, trace->filter_pids.entries); } } else if (perf_thread_map__pid(trace->evlist->core.threads, 0) =3D=3D -1= ) { @@ -4475,41 +4447,18 @@ static int trace__run(struct trace *trace, int argc= , const char **argv) err =3D evlist__open(evlist); if (err < 0) goto out_error_open; -#ifdef HAVE_BPF_SKEL - if (trace->syscalls.events.bpf_output) { - struct perf_cpu cpu; =20 - /* - * Set up the __augmented_syscalls__ BPF map to hold for each - * CPU the bpf-output event's file descriptor. - */ - perf_cpu_map__for_each_cpu(cpu, i, trace->syscalls.events.bpf_output->co= re.cpus) { - int mycpu =3D cpu.cpu; - - bpf_map__update_elem(trace->skel->maps.__augmented_syscalls__, - &mycpu, sizeof(mycpu), - xyarray__entry(trace->syscalls.events.bpf_output->core.fd, - mycpu, 0), - sizeof(__u32), BPF_ANY); - } - } + augmented_syscalls__setup_bpf_output(); =20 - if (trace->skel) - trace->filter_pids.map =3D trace->skel->maps.pids_filtered; -#endif err =3D trace__set_filter_pids(trace); if (err < 0) goto out_error_mem; =20 -#ifdef HAVE_BPF_SKEL - if (trace->skel && trace->skel->progs.sys_enter) { - /* - * TODO: Initialize for all host binary machine types, not just - * those matching the perf binary. - */ - trace__init_syscalls_bpf_prog_array_maps(trace, EM_HOST); - } -#endif + /* + * TODO: Initialize for all host binary machine types, not just + * those matching the perf binary. + */ + trace__init_syscalls_bpf_prog_array_maps(trace, EM_HOST); =20 if (trace->ev_qualifier_ids.nr > 0) { err =3D trace__set_ev_qualifier_filter(trace); @@ -5368,18 +5317,6 @@ static void trace__exit(struct trace *trace) #endif } =20 -#ifdef HAVE_BPF_SKEL -static int bpf__setup_bpf_output(struct evlist *evlist) -{ - int err =3D parse_event(evlist, "bpf-output/no-inherit=3D1,name=3D__augme= nted_syscalls__/"); - - if (err) - pr_debug("ERROR: failed to create the \"__augmented_syscalls__\" bpf-out= put event\n"); - - return err; -} -#endif - int cmd_trace(int argc, const char **argv) { const char *trace_usage[] =3D { @@ -5575,7 +5512,6 @@ int cmd_trace(int argc, const char **argv) "cgroup monitoring only available in system-wide mode"); } =20 -#ifdef HAVE_BPF_SKEL if (!trace.trace_syscalls) goto skip_augmentation; =20 @@ -5594,42 +5530,17 @@ int cmd_trace(int argc, const char **argv) goto skip_augmentation; } =20 - trace.skel =3D augmented_raw_syscalls_bpf__open(); - if (!trace.skel) { - pr_debug("Failed to open augmented syscalls BPF skeleton"); - } else { - /* - * Disable attaching the BPF programs except for sys_enter and - * sys_exit that tail call into this as necessary. - */ - struct bpf_program *prog; + err =3D augmented_syscalls__prepare(); + if (err < 0) + goto skip_augmentation; =20 - bpf_object__for_each_program(prog, trace.skel->obj) { - if (prog !=3D trace.skel->progs.sys_enter && prog !=3D trace.skel->prog= s.sys_exit) - bpf_program__set_autoattach(prog, /*autoattach=3D*/false); - } + trace__add_syscall_newtp(&trace); =20 - err =3D augmented_raw_syscalls_bpf__load(trace.skel); + err =3D augmented_syscalls__create_bpf_output(trace.evlist); + if (err =3D=3D 0) + trace.syscalls.events.bpf_output =3D evlist__last(trace.evlist); =20 - if (err < 0) { - libbpf_strerror(err, bf, sizeof(bf)); - pr_debug("Failed to load augmented syscalls BPF skeleton: %s\n", bf); - } else { - augmented_raw_syscalls_bpf__attach(trace.skel); - trace__add_syscall_newtp(&trace); - } - } - - err =3D bpf__setup_bpf_output(trace.evlist); - if (err) { - libbpf_strerror(err, bf, sizeof(bf)); - pr_err("ERROR: Setup BPF output event failed: %s\n", bf); - goto out; - } - trace.syscalls.events.bpf_output =3D evlist__last(trace.evlist); - assert(evsel__name_is(trace.syscalls.events.bpf_output, "__augmented_sysc= alls__")); skip_augmentation: -#endif err =3D -1; =20 if (trace.trace_pgfaults) { @@ -5812,8 +5723,6 @@ int cmd_trace(int argc, const char **argv) fclose(trace.output); out: trace__exit(&trace); -#ifdef HAVE_BPF_SKEL - augmented_raw_syscalls_bpf__destroy(trace.skel); -#endif + augmented_syscalls__cleanup(); return err; } diff --git a/tools/perf/util/Build b/tools/perf/util/Build index 4f7f072fa222ba80..7113dd237e3387db 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -175,6 +175,7 @@ perf-util-$(CONFIG_PERF_BPF_SKEL) +=3D btf.o =20 ifeq ($(CONFIG_TRACE),y) perf-util-$(CONFIG_PERF_BPF_SKEL) +=3D bpf-trace-summary.o + perf-util-$(CONFIG_PERF_BPF_SKEL) +=3D trace_augment.o endif =20 ifeq ($(CONFIG_LIBTRACEEVENT),y) diff --git a/tools/perf/util/bpf_skel/augmented_raw_syscalls.bpf.c b/tools/= perf/util/bpf_skel/augmented_raw_syscalls.bpf.c index e4352881e3faa602..cb86e261b4de0685 100644 --- a/tools/perf/util/bpf_skel/augmented_raw_syscalls.bpf.c +++ b/tools/perf/util/bpf_skel/augmented_raw_syscalls.bpf.c @@ -7,7 +7,6 @@ */ =20 #include "vmlinux.h" -#include "../trace_augment.h" =20 #include #include @@ -27,6 +26,8 @@ =20 #define MAX_CPUS 4096 =20 +#define TRACE_AUG_MAX_BUF 32 /* for buffer augmentation in perf trace */ + /* bpf-output associated map */ struct __augmented_syscalls__ { __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); diff --git a/tools/perf/util/trace_augment.c b/tools/perf/util/trace_augmen= t.c new file mode 100644 index 0000000000000000..56ed17534caa4f3f --- /dev/null +++ b/tools/perf/util/trace_augment.c @@ -0,0 +1,143 @@ +#include +#include + +#include "util/debug.h" +#include "util/evlist.h" +#include "util/trace_augment.h" + +#include "bpf_skel/augmented_raw_syscalls.skel.h" + +static struct augmented_raw_syscalls_bpf *skel; +static struct evsel *bpf_output; + +int augmented_syscalls__prepare(void) +{ + struct bpf_program *prog; + char buf[128]; + int err; + + skel =3D augmented_raw_syscalls_bpf__open(); + if (!skel) { + pr_debug("Failed to open augmented syscalls BPF skeleton\n"); + return -errno; + } + + /* + * Disable attaching the BPF programs except for sys_enter and + * sys_exit that tail call into this as necessary. + */ + bpf_object__for_each_program(prog, skel->obj) { + if (prog !=3D skel->progs.sys_enter && prog !=3D skel->progs.sys_exit) + bpf_program__set_autoattach(prog, /*autoattach=3D*/false); + } + + err =3D augmented_raw_syscalls_bpf__load(skel); + if (err < 0) { + libbpf_strerror(err, buf, sizeof(buf)); + pr_debug("Failed to load augmented syscalls BPF skeleton: %s\n", buf); + return err; + } + + augmented_raw_syscalls_bpf__attach(skel); + return 0; +} + +int augmented_syscalls__create_bpf_output(struct evlist *evlist) +{ + int err =3D parse_event(evlist, "bpf-output/no-inherit=3D1,name=3D__augme= nted_syscalls__/"); + + if (err) { + pr_err("ERROR: Setup BPF output event failed: %d\n", err); + return err; + } + + bpf_output =3D evlist__last(evlist); + assert(evsel__name_is(bpf_output, "__augmented_syscalls__")); + + return 0; +} + +void augmented_syscalls__setup_bpf_output(void) +{ + struct perf_cpu cpu; + int i; + + if (bpf_output =3D=3D NULL) + return; + + /* + * Set up the __augmented_syscalls__ BPF map to hold for each + * CPU the bpf-output event's file descriptor. + */ + perf_cpu_map__for_each_cpu(cpu, i, bpf_output->core.cpus) { + int mycpu =3D cpu.cpu; + + bpf_map__update_elem(skel->maps.__augmented_syscalls__, + &mycpu, sizeof(mycpu), + xyarray__entry(bpf_output->core.fd, + mycpu, 0), + sizeof(__u32), BPF_ANY); + } +} + +int augmented_syscalls__set_filter_pids(unsigned int nr, pid_t *pids) +{ + bool value =3D true; + int err =3D 0; + + if (skel =3D=3D NULL) + return 0; + + for (size_t i =3D 0; i < nr; ++i) { + err =3D bpf_map__update_elem(skel->maps.pids_filtered, &pids[i], + sizeof(*pids), &value, sizeof(value), + BPF_ANY); + if (err) + break; + } + return err; +} + +int augmented_syscalls__get_map_fds(int *enter_fd, int *exit_fd, int *beau= ty_fd) +{ + if (skel =3D=3D NULL) + return -1; + + *enter_fd =3D bpf_map__fd(skel->maps.syscalls_sys_enter); + *exit_fd =3D bpf_map__fd(skel->maps.syscalls_sys_exit); + *beauty_fd =3D bpf_map__fd(skel->maps.beauty_map_enter); + + if (*enter_fd < 0 || *exit_fd < 0 || *beauty_fd < 0) { + pr_err("Error: failed to get syscall or beauty map fd\n"); + return -1; + } + + return 0; +} + +struct bpf_program *augmented_syscalls__unaugmented(void) +{ + return skel->progs.syscall_unaugmented; +} + +struct bpf_program *augmented_syscalls__find_by_title(const char *name) +{ + struct bpf_program *pos; + const char *sec_name; + + if (skel->obj =3D=3D NULL) + return NULL; + + bpf_object__for_each_program(pos, skel->obj) { + sec_name =3D bpf_program__section_name(pos); + if (sec_name && !strcmp(sec_name, name)) + return pos; + } + + return NULL; +} + +void augmented_syscalls__cleanup(void) +{ + augmented_raw_syscalls_bpf__destroy(skel); +} diff --git a/tools/perf/util/trace_augment.h b/tools/perf/util/trace_augmen= t.h index 57a3e50459377983..4f729bc6775304b4 100644 --- a/tools/perf/util/trace_augment.h +++ b/tools/perf/util/trace_augment.h @@ -1,6 +1,66 @@ #ifndef TRACE_AUGMENT_H #define TRACE_AUGMENT_H =20 -#define TRACE_AUG_MAX_BUF 32 /* for buffer augmentation in perf trace */ +#include + +struct bpf_program; +struct evlist; + +#ifdef HAVE_BPF_SKEL + +int augmented_syscalls__prepare(void); +int augmented_syscalls__create_bpf_output(struct evlist *evlist); +void augmented_syscalls__setup_bpf_output(void); +int augmented_syscalls__set_filter_pids(unsigned int nr, pid_t *pids); +int augmented_syscalls__get_map_fds(int *enter_fd, int *exit_fd, int *beau= ty_fd); +struct bpf_program *augmented_syscalls__find_by_title(const char *name); +struct bpf_program *augmented_syscalls__unaugmented(void); +void augmented_syscalls__cleanup(void); + +#else /* !HAVE_BPF_SKEL */ + +static inline int augmented_syscalls__prepare(void) +{ + return -1; +} + +static inline int augmented_syscalls__create_bpf_output(struct evlist *evl= ist __maybe_unused) +{ + return -1; +} + +static inline void augmented_syscalls__setup_bpf_output(void) +{ +} + +static inline int augmented_syscalls__set_filter_pids(unsigned int nr __ma= ybe_unused, + pid_t *pids __maybe_unused) +{ + return 0; +} + +static inline int augmented_syscalls__get_map_fds(int *enter_fd __maybe_un= used, + int *exit_fd __maybe_unused, + int *beauty_fd __maybe_unused) +{ + return -1; +} + +static inline struct bpf_program * +augmented_syscalls__find_by_title(const char *name __maybe_unused) +{ + return NULL; +} + +static inline struct bpf_program *augmented_syscalls__unaugmented(void) +{ + return NULL; +} + +static inline void augmented_syscalls__cleanup(void) +{ +} + +#endif /* HAVE_BPF_SKEL */ =20 #endif --=20 2.49.0