perf record: Use a pinned BPF program for filter (v2)
Subsystems (2)
Namhyung Kim
maintainercover perf record: Use a pinned BPF program for filter (v2)
Hello,
This is to support the unprivileged BPF filter for profiling per-task events. Until now only root (or any user with CAP_BPF) can use the filter and we cannot add a new unprivileged BPF program types. After talking with the BPF folks at LSF/MM/BPF 2024, I was told that this is the way to go. Finally I managed to make it working with pinned BPF objects. :)
v2 changes)
* rebased onto Ian's UID/GID (non-sample data based) filter term change
* support separate lost counts for each use case
* update the test case to allow normal users (if supported)
This only supports the per-task mode for normal users and root still uses its own instance of the same BPF program - not shared with other users. But it requires the one-time setup (by root) before using it by normal users like below.
$ sudo perf record --setup-filter pin
This will load the BPF program and maps and pin them in the BPF-fs. Then normal users can use the filter.
$ perf record -o- -e cycles:u --filter 'period < 10000' perf test -w noploop | perf script -i-
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.011 MB - ]
perf 759982 448227.214189: 1 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2)
perf 759982 448227.214195: 1 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2)
perf 759982 448227.214196: 7 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2)
perf 759982 448227.214196: 223 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2)
perf 759982 448227.214198: 9475 cycles:u: ffffffff8ee012a0 [unknown] ([unknown])
perf 759982 448227.548608: 1 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf)
perf 759982 448227.548611: 1 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf)
perf 759982 448227.548612: 12 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf)
perf 759982 448227.548613: 466 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf)It's also possible to unload (and unpin, of course) using this command:
$ sudo perf record --setup-filter unpin
The code is avaiable in 'perf/pinned-filter-v2' branch at
git://git.kernel.org/pub/scm/linux/kernel/git/namhyung/linux-perf.git
Thanks,
Namhyung
Namhyung Kim (8):
perf bpf-filter: Make filters map a single entry hashmap perf bpf-filter: Pass 'target' to perf_bpf_filter__prepare() perf bpf-filter: Split per-task filter use case perf bpf-filter: Support pin/unpin BPF object
perf bpf-filter: Support separate lost counts for each filter perf record: Fix a potential error handling issue perf record: Add --setup-filter option
perf test: Update sample filtering test
tools/perf/Documentation/perf-record.txt | 5 + tools/perf/builtin-record.c | 23 +- tools/perf/builtin-stat.c | 2 +- tools/perf/builtin-top.c | 2 +- tools/perf/builtin-trace.c | 2 +- tools/perf/tests/shell/record_bpf_filter.sh | 13 +- tools/perf/util/bpf-filter.c | 406 +++++++++++++++++-- tools/perf/util/bpf-filter.h | 19 +- tools/perf/util/bpf_skel/sample-filter.h | 2 + tools/perf/util/bpf_skel/sample_filter.bpf.c | 75 +++- tools/perf/util/evlist.c | 5 +- tools/perf/util/evlist.h | 4 +- tools/perf/util/python.c | 3 +- 13 files changed, 485 insertions(+), 76 deletions(-)
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 1/8 perf bpf-filter: Make filters map a single entry hashmap
And the value is now an array. This is to support multiple filter entries in the map later.
No functional changes intended.
--- tools/perf/util/bpf-filter.c | 81 ++++++++++++++------ tools/perf/util/bpf_skel/sample-filter.h | 1 + tools/perf/util/bpf_skel/sample_filter.bpf.c | 39 +++++----- 3 files changed, 78 insertions(+), 43 deletions(-)
tools/perf/util/bpf-filter.c +56 -25
@@ -93,71 +93,102 @@ static int check_sample_flags(struct evsel *evsel, struct perf_bpf_filter_expr *int perf_bpf_filter__prepare (struct evsel *evsel) { -int i, x, y, fd; +int i, x, y, fd, ret;struct sample_filter_bpf *skel;struct bpf_program *prog;struct bpf_link *link;struct perf_bpf_filter_expr *expr; +struct perf_bpf_filter_entry *entry; + + entry =calloc (MAX_FILTERS ,sizeof (*entry)); +if (entry ==NULL ) +return -1 ; skel =sample_filter_bpf__open_and_load ();if (!skel) {pr_err ("Failed to load perf sample-filter BPF skeleton\n" ); -return -1 ; + ret = -EPERM ; + goto err; } i =0 ; fd =bpf_map__fd (skel->maps.filters);list_for_each_entry (expr, &evsel->bpf_filters, list) { -struct perf_bpf_filter_entry entry = { - .op = expr->op, - .part = expr->part, - .term = expr->term, - .value = expr->val, - }; +if (check_sample_flags (evsel, expr) <0 ) { + ret = -EINVAL ; + goto err; + } -if (check_sample_flags (evsel, expr) <0 ) -return -1 ; +if (i ==MAX_FILTERS ) { + ret = -E2BIG ; + goto err; + } -bpf_map_update_elem (fd, &i, &entry,BPF_ANY ); + entry[i].op = expr->op; + entry[i].part = expr->part; + entry[i].term = expr->term; + entry[i].value = expr->val; i++;if (expr->op ==PBF_OP_GROUP_BEGIN ) {struct perf_bpf_filter_expr *group;list_for_each_entry (group, &expr->groups, list) { -struct perf_bpf_filter_entry group_entry = { - .op = group->op, - .part = group->part, - .term = group->term, - .value = group->val, - }; -bpf_map_update_elem (fd, &i, &group_entry,BPF_ANY ); +if (i ==MAX_FILTERS ) { + ret = -E2BIG ; + goto err; + } + + entry[i].op = group->op; + entry[i].part = group->part; + entry[i].term = group->term; + entry[i].value = group->val; i++; } -memset (&entry,0 ,sizeof (entry)); - entry.op =PBF_OP_GROUP_END ; -bpf_map_update_elem (fd, &i, &entry,BPF_ANY ); +if (i ==MAX_FILTERS ) { + ret = -E2BIG ; + goto err; + } + + entry[i].op =PBF_OP_GROUP_END ; i++; } } -if (i >MAX_FILTERS ) { -pr_err ("Too many filters: %d (max = %d)\n" , i,MAX_FILTERS ); -return -1 ; +if (i <MAX_FILTERS ) { +/* to terminate the loop early */ + entry[i].op =PBF_OP_DONE ; + i++; + } + +/* The filters map has only one entry for now */ + i =0 ; +if (bpf_map_update_elem (fd, &i, entry,BPF_ANY ) <0 ) { + ret = -errno; +pr_err ("Failed to update the filter map\n" ); + goto err; } + prog = skel->progs.perf_sample_filter;for (x =0 ; x <xyarray__max_x (evsel->core.fd); x++) {for (y =0 ; y <xyarray__max_y (evsel->core.fd); y++) { link =bpf_program__attach_perf_event (prog,FD (evsel, x, y));if (IS_ERR (link)) {pr_err ("Failed to attach perf sample-filter program\n" ); -return PTR_ERR (link); + ret =PTR_ERR (link); + goto err; } } } +free (entry); evsel->bpf_skel = skel;return 0 ; + +err: +free (entry); +sample_filter_bpf__destroy (skel); +return ret; }int perf_bpf_filter__destroy (struct evsel *evsel)
tools/perf/util/bpf_skel/sample-filter.h +1 -0
@@ -14,6 +14,7 @@ enum perf_bpf_filter_op {PBF_OP_AND ,PBF_OP_GROUP_BEGIN ,PBF_OP_GROUP_END , + PBF_OP_DONE, }; enum perf_bpf_filter_term {
tools/perf/util/bpf_skel/sample_filter.bpf.c +21 -18
@@ -9,10 +9,10 @@/* BPF map that will be filled by user space */ struct filters { - __uint(type, BPF_MAP_TYPE_ARRAY); + __uint(type, BPF_MAP_TYPE_HASH); __type(key, int); - __type(value, struct perf_bpf_filter_entry); - __uint(max_entries, MAX_FILTERS); + __type(value, struct perf_bpf_filter_entry[MAX_FILTERS]); + __uint(max_entries, 1); } filters SEC(".maps");int dropped;
@@ -179,39 +179,39 @@ int perf_sample_filter(void *ctx)__u64 sample_data;int in_group =0 ;int group_result =0 ; -int i; +int i, k; kctx =bpf_cast_to_kern_ctx (ctx); -for (i =0 ; i <MAX_FILTERS ; i++) { -int key = i;/* needed for verifier :( */ + k =0 ; + entry =bpf_map_lookup_elem (&filters, &k); +if (entry ==NULL ) + goto drop; - entry =bpf_map_lookup_elem (&filters, &key); -if (entry ==NULL ) -break ; - sample_data =perf_get_sample (kctx, entry); +for (i =0 ; i <MAX_FILTERS ; i++) { + sample_data =perf_get_sample (kctx, &entry[i]); -switch (entry->op) { +switch (entry[i].op) {case PBF_OP_EQ : - CHECK_RESULT(sample_data, ==, entry->value) + CHECK_RESULT(sample_data, ==, entry[i].value) break;case PBF_OP_NEQ : - CHECK_RESULT(sample_data, !=, entry->value) + CHECK_RESULT(sample_data, !=, entry[i].value) break;case PBF_OP_GT : - CHECK_RESULT(sample_data, >, entry->value) + CHECK_RESULT(sample_data, >, entry[i].value) break;case PBF_OP_GE : - CHECK_RESULT(sample_data, >=, entry->value) + CHECK_RESULT(sample_data, >=, entry[i].value) break;case PBF_OP_LT : - CHECK_RESULT(sample_data, <, entry->value) + CHECK_RESULT(sample_data, <, entry[i].value) break;case PBF_OP_LE : - CHECK_RESULT(sample_data, <=, entry->value) + CHECK_RESULT(sample_data, <=, entry[i].value) break;case PBF_OP_AND : - CHECK_RESULT(sample_data, &, entry->value) + CHECK_RESULT(sample_data, &, entry[i].value) break;case PBF_OP_GROUP_BEGIN : in_group =1 ;
@@ -222,6 +222,9 @@ int perf_sample_filter(void *ctx) goto drop; in_group =0 ;break ; +case PBF_OP_DONE : +/* no failures so far, accept it */ +return 1 ; } }/* generate sample data */
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 2/8 perf bpf-filter: Pass 'target' to perf_bpf_filter__prepare()
In reply to Namhyung KimThis is needed to prepare target-specific actions in the later patch. We want to reuse the pinned BPF program and map for regular users to profile their own processes.
--- tools/perf/builtin-record.c | 2 +- tools/perf/builtin-stat.c | 2 +- tools/perf/builtin-top.c | 2 +- tools/perf/builtin-trace.c | 2 +- tools/perf/util/bpf-filter.c | 2 +- tools/perf/util/bpf-filter.h | 6 ++++-- tools/perf/util/evlist.c | 5 +++-- tools/perf/util/evlist.h | 4 +++- tools/perf/util/python.c | 3 ++- 9 files changed, 17 insertions(+), 11 deletions(-)
tools/perf/builtin-record.c +1 -1
@@ -1389,7 +1389,7 @@ static int record__open(struct record *rec) "even with a suitable vmlinux or kallsyms file.\n\n"); } -if (evlist__apply_filters (evlist, &pos)) { +if (evlist__apply_filters (evlist, &pos, &opts->target)) {pr_err ("failed to set filter \"%s\" on event %s with %d (%s)\n" , pos->filter ?:"BPF" ,evsel__name (pos), errno,str_error_r (errno, msg,sizeof (msg)));
tools/perf/builtin-stat.c +1 -1
@@ -833,7 +833,7 @@ static int __run_perf_stat(int argc, const char **argv, int run_idx)return -1 ; } -if (evlist__apply_filters (evsel_list, &counter)) { +if (evlist__apply_filters (evsel_list, &counter, &target)) {pr_err ("failed to set filter \"%s\" on event %s with %d (%s)\n" , counter->filter,evsel__name (counter), errno,str_error_r (errno, msg,sizeof (msg)));
tools/perf/builtin-top.c +1 -1
@@ -1055,7 +1055,7 @@ static int perf_top__start_counters(struct perf_top *top) } } -if (evlist__apply_filters (evlist, &counter)) { +if (evlist__apply_filters (evlist, &counter, &opts->target)) {pr_err ("failed to set filter \"%s\" on event %s with %d (%s)\n" , counter->filter ?:"BPF" ,evsel__name (counter), errno,str_error_r (errno, msg,sizeof (msg)));
tools/perf/builtin-trace.c +1 -1
@@ -3959,7 +3959,7 @@ static int trace__run(struct trace *trace, int argc, const char **argv) err =trace__expand_filters (trace, &evsel);if (err) goto out_delete_evlist; - err =evlist__apply_filters (evlist, &evsel); + err =evlist__apply_filters (evlist, &evsel, &trace->opts.target);if (err <0 ) goto out_error_apply_filters;
tools/perf/util/bpf-filter.c +1 -1
@@ -91,7 +91,7 @@ static int check_sample_flags(struct evsel *evsel, struct perf_bpf_filter_expr *return -1 ; } -int perf_bpf_filter__prepare (struct evsel *evsel) +int perf_bpf_filter__prepare (struct evsel *evsel,struct target *target__maybe_unused ) {int i, x, y, fd, ret;struct sample_filter_bpf *skel;
tools/perf/util/bpf-filter.h +4 -2
@@ -16,6 +16,7 @@ struct perf_bpf_filter_expr { };struct evsel ; +struct target ;#ifdef HAVE_BPF_SKEL struct perf_bpf_filter_expr *perf_bpf_filter_expr__new(enum perf_bpf_filter_term term,
@@ -23,7 +24,7 @@ struct perf_bpf_filter_expr *perf_bpf_filter_expr__new(enum perf_bpf_filter_termenum perf_bpf_filter_op op, unsigned long val);int perf_bpf_filter__parse (struct list_head *expr_head,const char *str); -int perf_bpf_filter__prepare (struct evsel *evsel); +int perf_bpf_filter__prepare (struct evsel *evsel,struct target *target);int perf_bpf_filter__destroy (struct evsel *evsel);u64 perf_bpf_filter__lost_count (struct evsel *evsel);
@@ -34,7 +35,8 @@ static inline int perf_bpf_filter__parse(struct list_head *expr_head __maybe_unu {return -EOPNOTSUPP ; } -static inline int perf_bpf_filter__prepare (struct evsel *evsel__maybe_unused ) +static inline int perf_bpf_filter__prepare (struct evsel *evsel__maybe_unused , +struct target *target__maybe_unused ) {return -EOPNOTSUPP ; }
tools/perf/util/evlist.c +3 -2
@@ -1086,7 +1086,8 @@ int evlist__create_maps(struct evlist *evlist, struct target *target)return -1 ; } -int evlist__apply_filters (struct evlist *evlist,struct evsel **err_evsel) +int evlist__apply_filters (struct evlist *evlist,struct evsel **err_evsel, +struct target *target) {struct evsel *evsel;int err =0 ;
@@ -1108,7 +1109,7 @@ int evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel)* non-tracepoint events can have BPF filters. */ if (!list_empty (&evsel->bpf_filters)) { - err =perf_bpf_filter__prepare (evsel); + err =perf_bpf_filter__prepare (evsel, target);if (err) { *err_evsel = evsel;break ;
tools/perf/util/evlist.h +3 -1
@@ -20,6 +20,7 @@ struct pollfd;struct thread_map ;struct perf_cpu_map ;struct record_opts ; +struct target ;/* * State machine of bkw_mmap_state:
@@ -212,7 +213,8 @@ void evlist__enable_non_dummy(struct evlist *evlist);void evlist__set_selected (struct evlist *evlist,struct evsel *evsel);int evlist__create_maps (struct evlist *evlist,struct target *target); -int evlist__apply_filters (struct evlist *evlist,struct evsel **err_evsel); +int evlist__apply_filters (struct evlist *evlist,struct evsel **err_evsel, +struct target *target);u64 __evlist__combined_sample_type (struct evlist *evlist);u64 evlist__combined_sample_type (struct evlist *evlist);
tools/perf/util/python.c +2 -1
@@ -178,7 +178,8 @@ int bpf_counter__disable(struct evsel *evsel __maybe_unused)// not to drag util/bpf-filter.c #ifdef HAVE_BPF_SKEL -int perf_bpf_filter__prepare (struct evsel *evsel__maybe_unused ) +int perf_bpf_filter__prepare (struct evsel *evsel__maybe_unused , +struct target *target__maybe_unused ) {return 0 ; }
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 3/8 perf bpf-filter: Split per-task filter use case
In reply to Namhyung KimIf the target is a list of tasks, it can use a shared hash map for filter expressions. The key of the filter map is an integer index like in an array. A separate pid_hash map is added to get the index for the filter map using the tgid.
For system-wide mode including per-cpu or per-user targets are handled by the single entry map like before.
--- tools/perf/util/bpf-filter.c | 186 +++++++++++++++---- tools/perf/util/bpf_skel/sample-filter.h | 1 + tools/perf/util/bpf_skel/sample_filter.bpf.c | 21 +++ 3 files changed, 168 insertions(+), 40 deletions(-)
tools/perf/util/bpf-filter.c +146 -40
@@ -3,10 +3,13 @@#include <bpf/bpf.h> #include <linux/err.h> +#include <api/fs/fs.h> #include <internal/xyarray.h> +#include <perf/threadmap.h> #include "util/debug.h" #include "util/evsel.h" +#include "util/target.h" #include "util/bpf-filter.h" #include <util/bpf-filter-flex.h>
@@ -91,38 +94,17 @@ static int check_sample_flags(struct evsel *evsel, struct perf_bpf_filter_expr *return -1 ; } -int perf_bpf_filter__prepare (struct evsel *evsel,struct target *target__maybe_unused ) +static int get_filter_entries (struct evsel *evsel,struct perf_bpf_filter_entry *entry) { -int i, x, y, fd, ret; -struct sample_filter_bpf *skel; -struct bpf_program *prog; -struct bpf_link *link; +int i =0 ;struct perf_bpf_filter_expr *expr; -struct perf_bpf_filter_entry *entry; - - entry =calloc (MAX_FILTERS ,sizeof (*entry)); -if (entry ==NULL ) -return -1 ; - - skel =sample_filter_bpf__open_and_load (); -if (!skel) { -pr_err ("Failed to load perf sample-filter BPF skeleton\n" ); - ret = -EPERM ; - goto err; - } - i =0 ; - fd =bpf_map__fd (skel->maps.filters);list_for_each_entry (expr, &evsel->bpf_filters, list) { -if (check_sample_flags (evsel, expr) <0 ) { - ret = -EINVAL ; - goto err; - } +if (check_sample_flags (evsel, expr) <0 ) +return -EINVAL ; -if (i ==MAX_FILTERS ) { - ret = -E2BIG ; - goto err; - } +if (i ==MAX_FILTERS ) +return -E2BIG ; entry[i].op = expr->op; entry[i].part = expr->part;
@@ -134,10 +116,8 @@ int perf_bpf_filter__prepare(struct evsel *evsel, struct target *target __maybe_struct perf_bpf_filter_expr *group;list_for_each_entry (group, &expr->groups, list) { -if (i ==MAX_FILTERS ) { - ret = -E2BIG ; - goto err; - } +if (i ==MAX_FILTERS ) +return -E2BIG ; entry[i].op = group->op; entry[i].part = group->part;
@@ -146,10 +126,8 @@ int perf_bpf_filter__prepare(struct evsel *evsel, struct target *target __maybe_ i++; } -if (i ==MAX_FILTERS ) { - ret = -E2BIG ; - goto err; - } +if (i ==MAX_FILTERS ) +return -E2BIG ; entry[i].op =PBF_OP_GROUP_END ; i++;
@@ -161,15 +139,143 @@ int perf_bpf_filter__prepare(struct evsel *evsel, struct target *target __maybe_ entry[i].op =PBF_OP_DONE ; i++; } +return 0 ; +} + +static int convert_to_tgid (int tid) +{ +char path[128 ]; +char *buf, *p, *q; +int tgid; +size_t len; + +scnprintf (path,sizeof (path),"%d/status" , tid); +if (procfs__read_str (path, &buf, &len) <0 ) +return -1 ; -/* The filters map has only one entry for now */ - i =0 ; -if (bpf_map_update_elem (fd, &i, entry,BPF_ANY ) <0 ) { - ret = -errno; -pr_err ("Failed to update the filter map\n" ); + p =strstr (buf,"Tgid:" ); +if (p ==NULL ) { +free (buf); +return -1 ; + } + + tgid =strtol (p +6 , &q,0 ); +free (buf); +if (*q !='\n' ) +return -1 ; + +return tgid; +} + +static int update_pid_hash (struct sample_filter_bpf *skel,struct evsel *evsel, +struct perf_bpf_filter_entry *entry) +{ +int filter_idx; +int nr, last; +int fd =bpf_map__fd (skel->maps.filters); +struct perf_thread_map *threads; + +/* Find the first available entry in the filters map */ +for (filter_idx =0 ; filter_idx <MAX_FILTERS ; filter_idx++) { +if (bpf_map_update_elem (fd, &filter_idx, entry,BPF_NOEXIST ) ==0 ) +break ; + } + +if (filter_idx ==MAX_FILTERS ) { +pr_err ("Too many users for the filter map\n" ); +return -EBUSY ; + } + + threads =perf_evsel__threads (&evsel->core); +if (threads ==NULL ) { +pr_err ("Cannot get the thread list of the event\n" ); +return -EINVAL ; + } + +/* save the index to a hash map */ + fd =bpf_map__fd (skel->maps.pid_hash); + + last =-1 ; + nr =perf_thread_map__nr (threads); +for (int i =0 ; i < nr; i++) { +int pid =perf_thread_map__pid (threads, i); +int tgid; + +/* it actually needs tgid, let's get tgid from /proc. */ + tgid =convert_to_tgid (pid); +if (tgid <0 ) { +/* the thread may be dead, ignore. */ +continue ; + } + +if (tgid == last) +continue ; + last = tgid; + +if (bpf_map_update_elem (fd, &tgid, &filter_idx,BPF_ANY ) <0 ) { +pr_err ("Failed to update the pid hash\n" ); +return -errno; + } +pr_debug ("pid hash: %d -> %d\n" , tgid, filter_idx); + } +return 0 ; +} + +int perf_bpf_filter__prepare (struct evsel *evsel,struct target *target) +{ +int i, x, y, fd, ret; +struct sample_filter_bpf *skel =NULL ; +struct bpf_program *prog; +struct bpf_link *link; +struct perf_bpf_filter_entry *entry; +bool needs_pid_hash = !target__has_cpu (target) && !target->uid_str; + + entry =calloc (MAX_FILTERS ,sizeof (*entry)); +if (entry ==NULL ) +return -1 ; + + ret =get_filter_entries (evsel, entry); +if (ret <0 ) { +pr_err ("Failed to process filter entries\n" ); + goto err; + } + + skel =sample_filter_bpf__open (); +if (!skel) { +pr_err ("Failed to open perf sample-filter BPF skeleton\n" ); + ret = -EPERM ; goto err; } +if (needs_pid_hash) { +bpf_map__set_max_entries (skel->maps.filters,MAX_FILTERS ); +bpf_map__set_max_entries (skel->maps.pid_hash,MAX_PIDS ); + skel->rodata->use_pid_hash =1 ; + } + +if (sample_filter_bpf__load (skel) <0 ) { +pr_err ("Failed to load perf sample-filter BPF skeleton\n" ); + ret = -EPERM ; + goto err; + } + +if (needs_pid_hash) { +/* The filters map is shared among other processes */ + ret =update_pid_hash (skel, evsel, entry); +if (ret <0 ) + goto err; + }else { + i =0 ; + fd =bpf_map__fd (skel->maps.filters); + +/* The filters map has only one entry in this case */ +if (bpf_map_update_elem (fd, &i, entry,BPF_ANY ) <0 ) { + ret = -errno; +pr_err ("Failed to update the filter map\n" ); + goto err; + } + } + prog = skel->progs.perf_sample_filter;for (x =0 ; x <xyarray__max_x (evsel->core.fd); x++) {for (y =0 ; y <xyarray__max_y (evsel->core.fd); y++) {
tools/perf/util/bpf_skel/sample-filter.h +1 -0
@@ -2,6 +2,7 @@#define PERF_UTIL_BPF_SKEL_SAMPLE_FILTER_H #define MAX_FILTERS 64 +#define MAX_PIDS (16 * 1024)/* supported filter operations */ enum perf_bpf_filter_op {
tools/perf/util/bpf_skel/sample_filter.bpf.c +21 -0
@@ -15,7 +15,16 @@ struct filters {__uint (max_entries,1 ); } filters SEC(".maps"); +/* tgid to filter index */ +struct pid_hash { + __uint(type, BPF_MAP_TYPE_HASH); + __type(key, int); + __type(value, int); + __uint(max_entries, 1); +} pid_hash SEC(".maps"); +int dropped; +volatile const int use_pid_hash;void *bpf_cast_to_kern_ctx (void *) __ksym;
@@ -184,6 +193,18 @@ int perf_sample_filter(void *ctx) kctx =bpf_cast_to_kern_ctx (ctx); k =0 ; + +if (use_pid_hash) { +int tgid =bpf_get_current_pid_tgid () >>32 ; +int *idx; + + idx =bpf_map_lookup_elem (&pid_hash, &tgid); +if (idx) + k = *idx; +else + goto drop; + } + entry =bpf_map_lookup_elem (&filters, &k);if (entry ==NULL ) goto drop;
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 4/8 perf bpf-filter: Support pin/unpin BPF object
In reply to Namhyung KimAnd use the pinned objects for unprivileged users to profile their own tasks. The BPF objects need to be pinned in the BPF-fs by root first and it'll be handled in the later patch.
--- tools/perf/util/bpf-filter.c | 230 +++++++++++++++++++++++++++++------ tools/perf/util/bpf-filter.h | 13 ++ 2 files changed, 209 insertions(+), 34 deletions(-)
tools/perf/util/bpf-filter.c +196 -34
@@ -1,5 +1,8 @@/* SPDX-License-Identifier: GPL-2.0 */ #include <stdlib.h> +#include <fcntl.h> +#include <sys/ioctl.h> +#include <sys/stat.h> #include <bpf/bpf.h> #include <linux/err.h>
@@ -23,6 +26,9 @@#define __PERF_SAMPLE_TYPE (tt, st, opt) { tt, #st, opt }#define PERF_SAMPLE_TYPE (_st, opt) __PERF_SAMPLE_TYPE(PBF_TERM_##_st, PERF_SAMPLE_##_st, opt) +/* Index in the pinned 'filters' map. Should be released after use. */ +static int pinned_filter_idx =-1 ; + static const struct perf_sample_info { enum perf_bpf_filter_term type; const char *name;
@@ -47,6 +53,8 @@ static const struct perf_sample_info { PERF_SAMPLE_TYPE(DATA_PAGE_SIZE, "--data-page-size"), }; +static int get_pinned_fd (const char *name); +static const struct perf_sample_info *get_sample_info (enum perf_bpf_filter_term type) {size_t i;
@@ -167,19 +175,26 @@ static int convert_to_tgid(int tid)return tgid; } -static int update_pid_hash (struct sample_filter_bpf *skel,struct evsel *evsel, -struct perf_bpf_filter_entry *entry) +static int update_pid_hash (struct evsel *evsel,struct perf_bpf_filter_entry *entry) {int filter_idx; -int nr, last; -int fd =bpf_map__fd (skel->maps.filters); +int fd, nr, last;struct perf_thread_map *threads; + fd =get_pinned_fd ("filters" ); +if (fd <0 ) { +pr_debug ("cannot get fd for 'filters' map\n" ); +return fd; + } +/* Find the first available entry in the filters map */ for (filter_idx =0 ; filter_idx <MAX_FILTERS ; filter_idx++) { -if (bpf_map_update_elem (fd, &filter_idx, entry,BPF_NOEXIST ) ==0 ) +if (bpf_map_update_elem (fd, &filter_idx, entry,BPF_NOEXIST ) ==0 ) { + pinned_filter_idx = filter_idx;break ; + } } +close (fd);if (filter_idx ==MAX_FILTERS ) {pr_err ("Too many users for the filter map\n" );
@@ -193,7 +208,9 @@ static int update_pid_hash(struct sample_filter_bpf *skel, struct evsel *evsel, }/* save the index to a hash map */ - fd =bpf_map__fd (skel->maps.pid_hash); + fd =get_pinned_fd ("pid_hash" ); +if (fd <0 ) +return fd; last =-1 ; nr =perf_thread_map__nr (threads);
@@ -214,10 +231,12 @@ static int update_pid_hash(struct sample_filter_bpf *skel, struct evsel *evsel,if (bpf_map_update_elem (fd, &tgid, &filter_idx,BPF_ANY ) <0 ) {pr_err ("Failed to update the pid hash\n" ); -return -errno; +close (fd); +return -1 ; }pr_debug ("pid hash: %d -> %d\n" , tgid, filter_idx); } +close (fd);return 0 ; }
@@ -240,40 +259,48 @@ int perf_bpf_filter__prepare(struct evsel *evsel, struct target *target) goto err; } - skel =sample_filter_bpf__open (); -if (!skel) { -pr_err ("Failed to open perf sample-filter BPF skeleton\n" ); - ret = -EPERM ; - goto err; - } +if (needs_pid_hash &&geteuid () !=0 ) { +/* The filters map is shared among other processes */ + ret =update_pid_hash (evsel, entry); +if (ret <0 ) + goto err; -if (needs_pid_hash) { -bpf_map__set_max_entries (skel->maps.filters,MAX_FILTERS ); -bpf_map__set_max_entries (skel->maps.pid_hash,MAX_PIDS ); - skel->rodata->use_pid_hash =1 ; + fd =get_pinned_fd ("perf_sample_filter" ); +if (fd <0 ) { + ret = fd; + goto err; + } + +for (x =0 ; x <xyarray__max_x (evsel->core.fd); x++) { +for (y =0 ; y <xyarray__max_y (evsel->core.fd); y++) { + ret =ioctl (FD (evsel, x, y),PERF_EVENT_IOC_SET_BPF , fd); +if (ret <0 ) { +pr_err ("Failed to attach perf sample-filter\n" ); + goto err; + } + } + } + +close (fd); +free (entry); +return 0 ; } -if (sample_filter_bpf__load (skel) <0 ) { + skel =sample_filter_bpf__open_and_load (); +if (!skel) { + ret = -errno;pr_err ("Failed to load perf sample-filter BPF skeleton\n" ); - ret = -EPERM ; goto err; } -if (needs_pid_hash) { -/* The filters map is shared among other processes */ - ret =update_pid_hash (skel, evsel, entry); -if (ret <0 ) - goto err; - }else { - i =0 ; - fd =bpf_map__fd (skel->maps.filters); - -/* The filters map has only one entry in this case */ -if (bpf_map_update_elem (fd, &i, entry,BPF_ANY ) <0 ) { - ret = -errno; -pr_err ("Failed to update the filter map\n" ); - goto err; - } + i =0 ; + fd =bpf_map__fd (skel->maps.filters); + +/* The filters map has only one entry in this case */ +if (bpf_map_update_elem (fd, &i, entry,BPF_ANY ) <0 ) { + ret = -errno; +pr_err ("Failed to update the filter map\n" ); + goto err; } prog = skel->progs.perf_sample_filter;
@@ -306,6 +333,15 @@ int perf_bpf_filter__destroy(struct evsel *evsel)free (expr); }sample_filter_bpf__destroy (evsel->bpf_skel); + +if (pinned_filter_idx >=0 ) { +int fd =get_pinned_fd ("filters" ); + +bpf_map_delete_elem (fd, &pinned_filter_idx); + pinned_filter_idx =-1 ; +close (fd); + } +return 0 ; }
@@ -349,3 +385,129 @@ int perf_bpf_filter__parse(struct list_head *expr_head, const char *str)return ret; } + +int perf_bpf_filter__pin (void ) +{ +struct sample_filter_bpf *skel; +char *path =NULL ; +int dir_fd, ret =-1 ; + + skel =sample_filter_bpf__open (); +if (!skel) { + ret = -errno; +pr_err ("Failed to open perf sample-filter BPF skeleton\n" ); + goto err; + } + +/* pinned program will use pid-hash */ +bpf_map__set_max_entries (skel->maps.filters,MAX_FILTERS ); +bpf_map__set_max_entries (skel->maps.pid_hash,MAX_PIDS ); + skel->rodata->use_pid_hash =1 ; + +if (sample_filter_bpf__load (skel) <0 ) { + ret = -errno; +pr_err ("Failed to load perf sample-filter BPF skeleton\n" ); + goto err; + } + +if (asprintf (&path,"%s/fs/bpf/%s" ,sysfs__mountpoint (), +PERF_BPF_FILTER_PIN_PATH ) <0 ) { + ret = -errno; +pr_err ("Failed to allocate pathname in the BPF-fs\n" ); + goto err; + } + + ret =bpf_object__pin (skel->obj, path); +if (ret <0 ) { +pr_err ("Failed to pin BPF filter objects\n" ); + goto err; + } + +/* setup access permissions for the pinned objects */ + dir_fd =open (path,O_PATH ); +if (dir_fd <0 ) { +bpf_object__unpin (skel->obj, path); + ret = dir_fd; + goto err; + } + +/* BPF-fs root has the sticky bit */ +if (fchmodat (dir_fd,".." ,01755 ,0 ) <0 ) { +pr_debug ("chmod for BPF-fs failed\n" ); + ret = -errno; + goto err_close; + } + +/* perf_filter directory */ +if (fchmodat (dir_fd,"." ,0755 ,0 ) <0 ) { +pr_debug ("chmod for perf_filter directory failed?\n" ); + ret = -errno; + goto err_close; + } + +/* programs need write permission for some reason */ +if (fchmodat (dir_fd,"perf_sample_filter" ,0777 ,0 ) <0 ) { +pr_debug ("chmod for perf_sample_filter failed\n" ); + ret = -errno; + } +/* maps */ +if (fchmodat (dir_fd,"filters" ,0666 ,0 ) <0 ) { +pr_debug ("chmod for filters failed\n" ); + ret = -errno; + } +if (fchmodat (dir_fd,"pid_hash" ,0666 ,0 ) <0 ) { +pr_debug ("chmod for pid_hash failed\n" ); + ret = -errno; + } + +err_close: +close (dir_fd); + +err: +free (path); +sample_filter_bpf__destroy (skel); +return ret; +} + +int perf_bpf_filter__unpin (void ) +{ +struct sample_filter_bpf *skel; +char *path =NULL ; +int ret =-1 ; + + skel =sample_filter_bpf__open_and_load (); +if (!skel) { + ret = -errno; +pr_err ("Failed to open perf sample-filter BPF skeleton\n" ); + goto err; + } + +if (asprintf (&path,"%s/fs/bpf/%s" ,sysfs__mountpoint (), +PERF_BPF_FILTER_PIN_PATH ) <0 ) { + ret = -errno; +pr_err ("Failed to allocate pathname in the BPF-fs\n" ); + goto err; + } + + ret =bpf_object__unpin (skel->obj, path); + +err: +free (path); +sample_filter_bpf__destroy (skel); +return ret; +} + +static int get_pinned_fd (const char *name) +{ +char *path =NULL ; +int fd; + +if (asprintf (&path,"%s/fs/bpf/%s/%s" ,sysfs__mountpoint (), +PERF_BPF_FILTER_PIN_PATH , name) <0 ) +return -1 ; + + fd =bpf_obj_get (path); + +free (path); +return fd; +}
tools/perf/util/bpf-filter.h +13 -0
@@ -18,6 +18,9 @@ struct perf_bpf_filter_expr {struct evsel ;struct target ; +/* path in BPF-fs for the pinned program and maps */ +#define PERF_BPF_FILTER_PIN_PATH "perf_filter" +#ifdef HAVE_BPF_SKEL struct perf_bpf_filter_expr *perf_bpf_filter_expr__new(enum perf_bpf_filter_term term, int part,
@@ -27,6 +30,8 @@ int perf_bpf_filter__parse(struct list_head *expr_head, const char *str);int perf_bpf_filter__prepare (struct evsel *evsel,struct target *target);int perf_bpf_filter__destroy (struct evsel *evsel);u64 perf_bpf_filter__lost_count (struct evsel *evsel); +int perf_bpf_filter__pin (void ); +int perf_bpf_filter__unpin (void );#else /* !HAVE_BPF_SKEL */
@@ -48,5 +53,13 @@ static inline u64 perf_bpf_filter__lost_count(struct evsel *evsel __maybe_unused {return 0 ; } +static inline int perf_bpf_filter__pin (void ) +{ +return -EOPNOTSUPP ; +} +static inline int perf_bpf_filter__unpin (void ) +{ +return -EOPNOTSUPP ; +}#endif /* HAVE_BPF_SKEL*/ #endif /* PERF_UTIL_BPF_FILTER_H */
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 5/8 perf bpf-filter: Support separate lost counts for each filter
In reply to Namhyung KimAs the BPF filter is shared between other processes, it should have its own counter for each invocation. Add a new array map (lost_count) to save the count using the same index as the filter. It should clear the count before running the filter.
--- tools/perf/util/bpf-filter.c | 37 ++++++++++++++++++-- tools/perf/util/bpf_skel/sample_filter.bpf.c | 15 ++++++-- 2 files changed, 48 insertions(+), 4 deletions(-)
tools/perf/util/bpf-filter.c +35 -2
@@ -260,11 +260,23 @@ int perf_bpf_filter__prepare(struct evsel *evsel, struct target *target) }if (needs_pid_hash &&geteuid () !=0 ) { +int zero =0 ; +/* The filters map is shared among other processes */ ret =update_pid_hash (evsel, entry);if (ret <0 ) goto err; + fd =get_pinned_fd ("dropped" ); +if (fd <0 ) { + ret = fd; + goto err; + } + +/* Reset the lost count */ +bpf_map_update_elem (fd, &pinned_filter_idx, &zero,BPF_ANY ); +close (fd); + fd =get_pinned_fd ("perf_sample_filter" );if (fd <0 ) { ret = fd;
@@ -347,9 +359,25 @@ int perf_bpf_filter__destroy(struct evsel *evsel)u64 perf_bpf_filter__lost_count (struct evsel *evsel) { -struct sample_filter_bpf *skel = evsel->bpf_skel; +int count =0 ; + +if (list_empty (&evsel->bpf_filters)) +return 0 ; + +if (pinned_filter_idx >=0 ) { +int fd =get_pinned_fd ("dropped" ); + +bpf_map_lookup_elem (fd, &pinned_filter_idx, &count); +close (fd); + }else if (evsel->bpf_skel) { +struct sample_filter_bpf *skel = evsel->bpf_skel; +int fd =bpf_map__fd (skel->maps.dropped); +int idx =0 ; -return skel ? skel->bss->dropped :0 ; +bpf_map_lookup_elem (fd, &idx, &count); + } + +return count; } struct perf_bpf_filter_expr *perf_bpf_filter_expr__new(enum perf_bpf_filter_term term,
@@ -402,6 +430,7 @@ int perf_bpf_filter__pin(void)/* pinned program will use pid-hash */ bpf_map__set_max_entries (skel->maps.filters,MAX_FILTERS );bpf_map__set_max_entries (skel->maps.pid_hash,MAX_PIDS ); +bpf_map__set_max_entries (skel->maps.dropped,MAX_FILTERS ); skel->rodata->use_pid_hash =1 ;if (sample_filter_bpf__load (skel) <0 ) {
@@ -459,6 +488,10 @@ int perf_bpf_filter__pin(void)pr_debug ("chmod for pid_hash failed\n" ); ret = -errno; } +if (fchmodat (dir_fd,"dropped" ,0666 ,0 ) <0 ) { +pr_debug ("chmod for dropped failed\n" ); + ret = -errno; + } err_close:close (dir_fd);
tools/perf/util/bpf_skel/sample_filter.bpf.c +13 -2
@@ -23,7 +23,14 @@ struct pid_hash {__uint (max_entries,1 ); } pid_hash SEC(".maps"); -int dropped; +/* tgid to filter index */ +struct lost_count { + __uint(type, BPF_MAP_TYPE_ARRAY); + __type(key, int); + __type(value, int); + __uint(max_entries, 1); +} dropped SEC(".maps"); +volatile const int use_pid_hash;void *bpf_cast_to_kern_ctx (void *) __ksym;
@@ -189,6 +196,7 @@ int perf_sample_filter(void *ctx)int in_group =0 ;int group_result =0 ;int i, k; +int *losts; kctx =bpf_cast_to_kern_ctx (ctx);
@@ -252,7 +260,10 @@ int perf_sample_filter(void *ctx)return 1 ; drop: -__sync_fetch_and_add (&dropped,1 ); + losts =bpf_map_lookup_elem (&dropped, &k); +if (losts !=NULL ) +__sync_fetch_and_add (losts,1 ); +return 0 ; }
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 6/8 perf record: Fix a potential error handling issue
In reply to Namhyung KimThe evlist is allocated at the beginning of cmd_record(). Also free-ing thread masks should be paired with record__init_thread_masks() which is called right before __cmd_record().
Let's change the order of these functions to release the resources correctly in case of errors. This is maybe fine as the process exits, but it might be a problem if it manages some system-wide resources that live longer than the process.
--- tools/perf/builtin-record.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
tools/perf/builtin-record.c +3 -3
@@ -4242,13 +4242,13 @@ int cmd_record(int argc, const char **argv) err =__cmd_record (&record, argc, argv); out: -evlist__delete (rec->evlist); +record__free_thread_masks (rec, rec->nr_threads); + rec->nr_threads =0 ;symbol__exit ();auxtrace_record__free (rec->itr); out_opts: -record__free_thread_masks (rec, rec->nr_threads); - rec->nr_threads =0 ;evlist__close_control (rec->opts.ctl_fd, rec->opts.ctl_fd_ack, &rec->opts.ctl_fd_close); +evlist__delete (rec->evlist);return err; }
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 7/8 perf record: Add --setup-filter option
In reply to Namhyung KimTo allow BPF filters for unprivileged users it needs to pin the BPF objects to BPF-fs first. Let's add a new option to pin and unpin the objects easily. I'm not sure 'perf record' is a right place to do this but I don't have a better idea right now.
$ sudo perf record --setup-filter pin
The above command would pin BPF program and maps for the filter when the system has BPF-fs (usually at /sys/fs/bpf/). To unpin the objects, users can run the following command (as root).
$ sudo perf record --setup-filter unpin
--- tools/perf/Documentation/perf-record.txt | 5 +++++ tools/perf/builtin-record.c | 15 +++++++++++++++ 2 files changed, 20 insertions(+)
tools/perf/Documentation/perf-record.txt +5 -0
@@ -828,6 +828,11 @@ filtered through the mask provided by -C option. only, as of now. So the applications built without the frame pointer might see bogus addresses. +--setup-filter=<action>:: + Prepare BPF filter to be used by regular users. The action should be + either "pin" or "unpin". The filter can be used after it's pinned. + + include::intel-hybrid.txt[] SEE ALSO
tools/perf/builtin-record.c +15 -0
@@ -171,6 +171,7 @@ struct record {bool timestamp_filename;bool timestamp_boundary;bool off_cpu; +const char *filter_action;struct switch_output switch_output;unsigned long long samples;unsigned long output_max_size;/* = 0: unlimited */
@@ -3557,6 +3558,8 @@ static struct option __record_options[] = { "write collected trace data into several data files using parallel threads", record__parse_threads),OPT_BOOLEAN (0 ,"off-cpu" , &record.off_cpu,"Enable off-cpu analysis" ), +OPT_STRING (0 ,"setup-filter" , &record.filter_action,"pin|unpin" , +"BPF filter action" ), OPT_END() };
@@ -4086,6 +4089,18 @@ int cmd_record(int argc, const char **argv)pr_warning ("WARNING: --timestamp-filename option is not available in parallel streaming mode.\n" ); } +if (rec->filter_action) { +if (!strcmp (rec->filter_action,"pin" )) + err =perf_bpf_filter__pin (); +else if (!strcmp (rec->filter_action,"unpin" )) + err =perf_bpf_filter__unpin (); +else { +pr_warning ("Unknown BPF filter action: %s\n" , rec->filter_action); + err = -EINVAL ; + } + goto out_opts; + } +/* * Allow aliases to facilitate the lookup of symbols for address * filters. Refer to auxtrace_parse_filters().
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerPATCH 8/8 perf test: Update sample filtering test
In reply to Namhyung KimNow it can run the BPF filtering test with normal user if the BPF objects are pinned by 'sudo perf record --setup-filter pin'. Let's update the test case to verify the behavior. It'll skip the test if the filter check is failed from a normal user, but it shows a message how to set up the filters.
First, run the test as a normal user and it fails.
$ perf test -vv filtering 95: perf record sample filtering (by BPF) tests: --- start --- test child forked, pid 425677 Checking BPF-filter privilege try 'sudo perf record --setup-filter pin' first. <<<--- here bpf-filter test [Skipped permission] ---- end(-2) ---- 95: perf record sample filtering (by BPF) tests : Skip
According to the message, run the perf record command to pin the BPF objects.
$ sudo perf record --setup-filter pin
And re-run the test as a normal user.
$ perf test -vv filtering 95: perf record sample filtering (by BPF) tests: --- start --- test child forked, pid 424486 Checking BPF-filter privilege Basic bpf-filter test Basic bpf-filter test [Success] Failing bpf-filter test Error: task-clock event does not have PERF_SAMPLE_CPU Failing bpf-filter test [Success] Group bpf-filter test Error: task-clock event does not have PERF_SAMPLE_CPU Error: task-clock event does not have PERF_SAMPLE_CODE_PAGE_SIZE Group bpf-filter test [Success] ---- end(0) ---- 95: perf record sample filtering (by BPF) tests : Ok
--- tools/perf/tests/shell/record_bpf_filter.sh | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
tools/perf/tests/shell/record_bpf_filter.sh +7 -6
@@ -22,15 +22,16 @@ trap trap_cleanup EXIT TERM INT test_bpf_filter_priv() { echo "Checking BPF-filter privilege" - if [ "$(id -u)" != 0 ] - then - echo "bpf-filter test [Skipped permission]" - err=2 - return - fi if ! perf record -e task-clock --filter 'period > 1' \ -o /dev/null --quiet true 2>&1 then + if [ "$(id -u)" != 0 ] + then + echo "try 'sudo perf record --setup-filter pin' first." + echo "bpf-filter test [Skipped permission]" + err=2 + return + fi echo "bpf-filter test [Skipped missing BPF support]" err=2 return
Signature · 1 line
2.45.2.741.gdbec12cfda-goog
Namhyung Kim
maintainerUgh, forgot to CC bpf list/folks.. ;-p
Quoted 79 lines · Namhyung Kim
Hello,
This is to support the unprivileged BPF filter for profiling per-task events. Until now only root (or any user with
CAP_BPF) can use the filter and we cannot add a new unprivileged BPF program types. After talking with the BPF folks at LSF/MM/BPF 2024, I was told that this is the way to go. Finally I managed to make it working with pinned BPF objects. :)v2 changes)
* rebased onto Ian's UID/GID (non-sample data based) filter term change
* support separate lost counts for each use case
* update the test case to allow normal users (if supported)This only supports the per-task mode for normal users and root still uses its own instance of the same BPF program - not shared with other users. But it requires the one-time setup (by root) before using it by normal users like below.
$ sudo perf record --setup-filter pinThis will load the BPF program and maps and pin them in the BPF-fs. Then normal users can use the filter.
$ perf record -o- -e cycles:u --filter 'period < 10000' perf test -w noploop | perf script -i- [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.011 MB - ] perf 759982 448227.214189: 1 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2) perf 759982 448227.214195: 1 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2) perf 759982 448227.214196: 7 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2) perf 759982 448227.214196: 223 cycles:u: 7f153719f4d0 _start+0x0 (/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2) perf 759982 448227.214198: 9475 cycles:u: ffffffff8ee012a0 [unknown] ([unknown]) perf 759982 448227.548608: 1 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf) perf 759982 448227.548611: 1 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf) perf 759982 448227.548612: 12 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf) perf 759982 448227.548613: 466 cycles:u: 559a9f03c81c noploop+0x5c (/home/namhyung/linux/tools/perf/perf)It's also possible to unload (and unpin, of course) using this command:
$ sudo perf record --setup-filter unpinThe code is avaiable in 'perf/pinned-filter-v2' branch at
git://git.kernel.org/pub/scm/linux/kernel/git/namhyung/linux-perf.gitThanks,
NamhyungNamhyung Kim (8):
perf bpf-filter: Make filters map a single entry hashmap perf bpf-filter: Pass 'target' toperf_bpf_filter__prepare()perf bpf-filter: Split per-task filter use case perf bpf-filter: Support pin/unpin BPF object
perf bpf-filter: Support separate lost counts for each filter perf record: Fix a potential error handling issue perf record: Add --setup-filter option
perf test: Update sample filtering testtools/perf/Documentation/perf-record.txt | 5 + tools/perf/builtin-record.c | 23 +- tools/perf/builtin-stat.c | 2 +- tools/perf/builtin-top.c | 2 +- tools/perf/builtin-trace.c | 2 +- tools/perf/tests/shell/record_bpf_filter.sh | 13 +- tools/perf/util/bpf-filter.c | 406 +++++++++++++++++-- tools/perf/util/bpf-filter.h | 19 +- tools/perf/util/bpf_skel/sample-filter.h | 2 + tools/perf/util/bpf_skel/sample_filter.bpf.c | 75 +++- tools/perf/util/evlist.c | 5 +- tools/perf/util/evlist.h | 4 +- tools/perf/util/python.c | 3 +- 13 files changed, 485 insertions(+), 76 deletions(-)--
2.45.2.741.gdbec12cfda-goog