1#include <stdio.h>
2#include <fcntl.h>
3#include <stdint.h>
4#include <stdlib.h>
5
6#include <linux/err.h>
7
8#include "util/ftrace.h"
9#include "util/cpumap.h"
10#include "util/thread_map.h"
11#include "util/debug.h"
12#include "util/evlist.h"
13#include "util/bpf_counter.h"
14
15#include "util/bpf_skel/func_latency.skel.h"
16
17static struct func_latency_bpf *skel;
18
19int perf_ftrace__latency_prepare_bpf(struct perf_ftrace *ftrace)
20{
21 int fd, err;
22 int i, ncpus = 1, ntasks = 1;
23 struct filter_entry *func;
24
25 if (!list_is_singular(&ftrace->filters)) {
26 pr_err("ERROR: %s target function(s).\n",
27 list_empty(&ftrace->filters) ? "No" : "Too many");
28 return -1;
29 }
30
31 func = list_first_entry(&ftrace->filters, struct filter_entry, list);
32
33 skel = func_latency_bpf__open();
34 if (!skel) {
35 pr_err("Failed to open func latency skeleton\n");
36 return -1;
37 }
38
39
40 if (ftrace->target.cpu_list) {
41 ncpus = perf_cpu_map__nr(ftrace->evlist->core.user_requested_cpus);
42 bpf_map__set_max_entries(skel->maps.cpu_filter, ncpus);
43 }
44
45 if (target__has_task(&ftrace->target) || target__none(&ftrace->target)) {
46 ntasks = perf_thread_map__nr(ftrace->evlist->core.threads);
47 bpf_map__set_max_entries(skel->maps.task_filter, ntasks);
48 }
49
50 set_max_rlimit();
51
52 err = func_latency_bpf__load(skel);
53 if (err) {
54 pr_err("Failed to load func latency skeleton\n");
55 goto out;
56 }
57
58 if (ftrace->target.cpu_list) {
59 u32 cpu;
60 u8 val = 1;
61
62 skel->bss->has_cpu = 1;
63 fd = bpf_map__fd(skel->maps.cpu_filter);
64
65 for (i = 0; i < ncpus; i++) {
66 cpu = perf_cpu_map__cpu(ftrace->evlist->core.user_requested_cpus, i).cpu;
67 bpf_map_update_elem(fd, &cpu, &val, BPF_ANY);
68 }
69 }
70
71 if (target__has_task(&ftrace->target) || target__none(&ftrace->target)) {
72 u32 pid;
73 u8 val = 1;
74
75 skel->bss->has_task = 1;
76 fd = bpf_map__fd(skel->maps.task_filter);
77
78 for (i = 0; i < ntasks; i++) {
79 pid = perf_thread_map__pid(ftrace->evlist->core.threads, i);
80 bpf_map_update_elem(fd, &pid, &val, BPF_ANY);
81 }
82 }
83
84 skel->bss->use_nsec = ftrace->use_nsec;
85
86 skel->links.func_begin = bpf_program__attach_kprobe(skel->progs.func_begin,
87 false, func->name);
88 if (IS_ERR(skel->links.func_begin)) {
89 pr_err("Failed to attach fentry program\n");
90 err = PTR_ERR(skel->links.func_begin);
91 goto out;
92 }
93
94 skel->links.func_end = bpf_program__attach_kprobe(skel->progs.func_end,
95 true, func->name);
96 if (IS_ERR(skel->links.func_end)) {
97 pr_err("Failed to attach fexit program\n");
98 err = PTR_ERR(skel->links.func_end);
99 goto out;
100 }
101
102
103 return open("/dev/null", O_RDONLY);
104
105out:
106 return err;
107}
108
109int perf_ftrace__latency_start_bpf(struct perf_ftrace *ftrace __maybe_unused)
110{
111 skel->bss->enabled = 1;
112 return 0;
113}
114
115int perf_ftrace__latency_stop_bpf(struct perf_ftrace *ftrace __maybe_unused)
116{
117 skel->bss->enabled = 0;
118 return 0;
119}
120
121int perf_ftrace__latency_read_bpf(struct perf_ftrace *ftrace __maybe_unused,
122 int buckets[])
123{
124 int i, fd, err;
125 u32 idx;
126 u64 *hist;
127 int ncpus = cpu__max_cpu().cpu;
128
129 fd = bpf_map__fd(skel->maps.latency);
130
131 hist = calloc(ncpus, sizeof(*hist));
132 if (hist == NULL)
133 return -ENOMEM;
134
135 for (idx = 0; idx < NUM_BUCKET; idx++) {
136 err = bpf_map_lookup_elem(fd, &idx, hist);
137 if (err) {
138 buckets[idx] = 0;
139 continue;
140 }
141
142 for (i = 0; i < ncpus; i++)
143 buckets[idx] += hist[i];
144 }
145
146 free(hist);
147 return 0;
148}
149
150int perf_ftrace__latency_cleanup_bpf(struct perf_ftrace *ftrace __maybe_unused)
151{
152 func_latency_bpf__destroy(skel);
153 return 0;
154}
155
