"even with a suitable vmlinux or kallsyms file.\n\n");
        }
 
-       if (perf_evlist__apply_filters(evlist, &pos)) {
+       if (evlist__apply_filters(evlist, &pos)) {
                pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
                        pos->filter, evsel__name(pos), errno,
                        str_error_r(errno, msg, sizeof(msg)));
 
                        return -1;
        }
 
-       if (perf_evlist__apply_filters(evsel_list, &counter)) {
+       if (evlist__apply_filters(evsel_list, &counter)) {
                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)));
 
                thread = parent;
        }
 
-       err = perf_evlist__append_tp_filter_pids(trace->evlist, nr, pids);
+       err = evlist__append_tp_filter_pids(trace->evlist, nr, pids);
        if (!err && trace->filter_pids.map)
                err = bpf_map__set_filter_pids(trace->filter_pids.map, nr, pids);
 
         * we fork the workload in evlist__prepare_workload.
         */
        if (trace->filter_pids.nr > 0) {
-               err = perf_evlist__append_tp_filter_pids(trace->evlist, trace->filter_pids.nr,
-                                                        trace->filter_pids.entries);
+               err = evlist__append_tp_filter_pids(trace->evlist, trace->filter_pids.nr,
+                                                   trace->filter_pids.entries);
                if (!err && trace->filter_pids.map) {
                        err = bpf_map__set_filter_pids(trace->filter_pids.map, trace->filter_pids.nr,
                                                       trace->filter_pids.entries);
        err = trace__expand_filters(trace, &evsel);
        if (err)
                goto out_delete_evlist;
-       err = perf_evlist__apply_filters(evlist, &evsel);
+       err = evlist__apply_filters(evlist, &evsel);
        if (err < 0)
                goto out_error_apply_filters;
 
 
                __evsel__reset_sample_bit(evsel, bit);
 }
 
-int perf_evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel)
+int evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel)
 {
        struct evsel *evsel;
        int err = 0;
        return err;
 }
 
-int perf_evlist__set_tp_filter(struct evlist *evlist, const char *filter)
+int evlist__set_tp_filter(struct evlist *evlist, const char *filter)
 {
        struct evsel *evsel;
        int err = 0;
        return err;
 }
 
-int perf_evlist__append_tp_filter(struct evlist *evlist, const char *filter)
+int evlist__append_tp_filter(struct evlist *evlist, const char *filter)
 {
        struct evsel *evsel;
        int err = 0;
        return NULL;
 }
 
-int perf_evlist__set_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids)
+int evlist__set_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids)
 {
        char *filter = asprintf__tp_filter_pids(npids, pids);
-       int ret = perf_evlist__set_tp_filter(evlist, filter);
+       int ret = evlist__set_tp_filter(evlist, filter);
 
        free(filter);
        return ret;
 }
 
-int perf_evlist__set_tp_filter_pid(struct evlist *evlist, pid_t pid)
+int evlist__set_tp_filter_pid(struct evlist *evlist, pid_t pid)
 {
-       return perf_evlist__set_tp_filter_pids(evlist, 1, &pid);
+       return evlist__set_tp_filter_pids(evlist, 1, &pid);
 }
 
-int perf_evlist__append_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids)
+int evlist__append_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids)
 {
        char *filter = asprintf__tp_filter_pids(npids, pids);
-       int ret = perf_evlist__append_tp_filter(evlist, filter);
+       int ret = evlist__append_tp_filter(evlist, filter);
 
        free(filter);
        return ret;
 }
 
-int perf_evlist__append_tp_filter_pid(struct evlist *evlist, pid_t pid)
+int evlist__append_tp_filter_pid(struct evlist *evlist, pid_t pid)
 {
-       return perf_evlist__append_tp_filter_pids(evlist, 1, &pid);
+       return evlist__append_tp_filter_pids(evlist, 1, &pid);
 }
 
 bool evlist__valid_sample_type(struct evlist *evlist)
 
 #define perf_evlist__reset_sample_bit(evlist, bit) \
        __perf_evlist__reset_sample_bit(evlist, PERF_SAMPLE_##bit)
 
-int perf_evlist__set_tp_filter(struct evlist *evlist, const char *filter);
-int perf_evlist__set_tp_filter_pid(struct evlist *evlist, pid_t pid);
-int perf_evlist__set_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids);
+int evlist__set_tp_filter(struct evlist *evlist, const char *filter);
+int evlist__set_tp_filter_pid(struct evlist *evlist, pid_t pid);
+int evlist__set_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids);
 
-int perf_evlist__append_tp_filter(struct evlist *evlist, const char *filter);
+int evlist__append_tp_filter(struct evlist *evlist, const char *filter);
 
-int perf_evlist__append_tp_filter_pid(struct evlist *evlist, pid_t pid);
-int perf_evlist__append_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids);
+int evlist__append_tp_filter_pid(struct evlist *evlist, pid_t pid);
+int evlist__append_tp_filter_pids(struct evlist *evlist, size_t npids, pid_t *pids);
 
 struct evsel *
 perf_evlist__find_tracepoint_by_id(struct evlist *evlist, int id);
                               struct evsel *evsel);
 
 int perf_evlist__create_maps(struct evlist *evlist, struct target *target);
-int perf_evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel);
+int evlist__apply_filters(struct evlist *evlist, struct evsel **err_evsel);
 
 void __evlist__set_leader(struct list_head *list);
 void evlist__set_leader(struct evlist *evlist);