From nobody Wed Oct 8 22:14:51 2025 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 04B29219E0; Mon, 23 Jun 2025 22:57:29 +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=1750719450; cv=none; b=f58kASKhWux4IlNyWdiGHfCThCAkJ8Yg7gYobZJCrJlQklad5TQFlqrP/ijpTdBiUw8n2jeGn5gDNLJEq8FBD9VPK7SpNU1097QbXbcp4lwx2bp6a6zQzuugrD5OLRWsdGU5dOIMrQC+8jL75UvZjS5tneQBy7EGMtXM20W92xI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1750719450; c=relaxed/simple; bh=V5Nft0LcU0+YQTEjKPejUnYpjLgWUdfTuzI+mM8M5Go=; h=From:To:Cc:Subject:Date:Message-ID:MIME-Version; b=DthYbYmy9NTzWAVcGi+Q1yOC4JUKJfQPv727DZnyZj0DMZDrGPglDfro2PFHnGeWnFu6j652YvuR/Yfl0+qwyIZtK/x3Ud8jZl8vYwHaSk84NhN/NBKrHGUSQsUKmY61LhldmT61Vjd7+XBIpH4yEkPfVZpZQx5X9Q+YbGBMhis= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=a1B465to; 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="a1B465to" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0B30CC4CEEA; Mon, 23 Jun 2025 22:57:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1750719449; bh=V5Nft0LcU0+YQTEjKPejUnYpjLgWUdfTuzI+mM8M5Go=; h=From:To:Cc:Subject:Date:From; b=a1B465to1mLVZJ2XUd6EDduIgLV5O5jPQvShcAICIQAo/7rCxOGSWLVpkhxH/hNlX X2CiyG95n4CXssau3xKG9k9tj3xo0OooAC1Jr+JH2YxX2hILSUgT+C05BOrmZllFmJ 0BcYQ6EdkrU4xn3JM+s14ocZ+4xs94F/AkHimlRpFl4/JL8jBO7wMtzLhygml5o7Yg VO7Y+pLd5z4Kt+vMm6fgHOS5ZpMyyN+NjXofC1tNQsKfO9Cr2i18Pi6EdnAMWkKDM4 D9C7SUsRe4zqWfjEkxqh7B2gqTNv4Nlyvj3GBJsRLHNClONSyiDaebP2ypxvb3J3IU pJdkPsIM1xXAA== 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 v2] perf trace: Split BPF skel code to util/bpf_trace_augment.c Date: Mon, 23 Jun 2025 15:57:21 -0700 Message-ID: <20250623225721.21553-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. Reviewed-by: Howard Chu Signed-off-by: Namhyung Kim Tested-by: Arnaldo Carvalho de Melo --- v2) * rename to bpf_trace_augment.c * rebase to the current perf-tools-next * add Howard's Reviewed-by tools/perf/builtin-trace.c | 187 +++++------------- tools/perf/util/Build | 1 + .../bpf_skel/augmented_raw_syscalls.bpf.c | 3 +- tools/perf/util/bpf_trace_augment.c | 143 ++++++++++++++ tools/perf/util/trace_augment.h | 62 +++++- 5 files changed, 255 insertions(+), 141 deletions(-) create mode 100644 tools/perf/util/bpf_trace_augment.c diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c index bf9b5d0630d3ddac..56c0dd5acf73073e 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 @@ -3701,7 +3695,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; @@ -3719,26 +3716,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; @@ -3746,19 +3725,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: @@ -3768,7 +3747,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) @@ -3785,13 +3764,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) @@ -3901,7 +3880,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; @@ -3967,7 +3946,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 @@ -3983,12 +3962,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 @@ -4058,7 +4042,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 /* @@ -4083,7 +4067,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) { @@ -4092,24 +4082,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; @@ -4138,8 +4110,8 @@ static int trace__set_filter_loop_pids(struct trace *= trace) thread__put(thread); =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; } @@ -4156,8 +4128,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= ) { @@ -4480,41 +4452,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); @@ -5375,18 +5324,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 { @@ -5580,7 +5517,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 @@ -5599,42 +5535,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) { @@ -5831,8 +5742,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 7910d908c814feec..17c7b71128d15970 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 bpf_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/bpf_trace_augment.c b/tools/perf/util/bpf_trac= e_augment.c new file mode 100644 index 0000000000000000..56ed17534caa4f3f --- /dev/null +++ b/tools/perf/util/bpf_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