Debian Codegraph @

tools/tracing/rtla/src/timerlat_bpf.c

raw
1 // SPDX-License-Identifier: GPL-2.0
2 #ifdef HAVE_BPF_SKEL
3 #define _GNU_SOURCE
4 #include "timerlat.h"
5 #include "timerlat_bpf.h"
6 #include "timerlat.skel.h"
7
8 static struct timerlat_bpf *bpf;
9
10 /* BPF object and program for action program */
11 static struct bpf_object *obj;
12 static struct bpf_program *prog;
13
14 /*
15 * timerlat_bpf_init - load and initialize BPF program to collect timerlat data
16 */
17 int timerlat_bpf_init(struct timerlat_params *params)
18 {
19 int err;
20
21 debug_msg("Loading BPF program\n");
22
23 bpf = timerlat_bpf__open();
24 if (!bpf)
25 return 1;
26
27 /* Pass common options */
28 bpf->rodata->output_divisor = params->common.output_divisor;
29 bpf->rodata->entries = params->common.hist.entries;
30 bpf->rodata->irq_threshold = params->common.stop_us;
31 bpf->rodata->thread_threshold = params->common.stop_total_us;
32 bpf->rodata->aa_only = params->common.aa_only;
33
34 if (params->common.hist.entries != 0) {
35 /* Pass histogram options */
36 bpf->rodata->bucket_size = params->common.hist.bucket_size;
37
38 /* Set histogram array sizes */
39 bpf_map__set_max_entries(bpf->maps.hist_irq, params->common.hist.entries);
40 bpf_map__set_max_entries(bpf->maps.hist_thread, params->common.hist.entries);
41 bpf_map__set_max_entries(bpf->maps.hist_user, params->common.hist.entries);
42 } else {
43 /* No entries, disable histogram */
44 bpf_map__set_autocreate(bpf->maps.hist_irq, false);
45 bpf_map__set_autocreate(bpf->maps.hist_thread, false);
46 bpf_map__set_autocreate(bpf->maps.hist_user, false);
47 }
48
49 if (params->common.aa_only) {
50 /* Auto-analysis only, disable summary */
51 bpf_map__set_autocreate(bpf->maps.summary_irq, false);
52 bpf_map__set_autocreate(bpf->maps.summary_thread, false);
53 bpf_map__set_autocreate(bpf->maps.summary_user, false);
54 }
55
56 /* Load and verify BPF program */
57 err = timerlat_bpf__load(bpf);
58 if (err) {
59 timerlat_bpf__destroy(bpf);
60 return err;
61 }
62
63 return 0;
64 }
65
66 /*
67 * timerlat_bpf_set_action - set action on threshold executed on BPF side
68 */
69 static int timerlat_bpf_set_action(struct bpf_program *prog)
70 {
71 unsigned int key = 0, value = bpf_program__fd(prog);
72
73 return bpf_map__update_elem(bpf->maps.bpf_action,
74 &key, sizeof(key),
75 &value, sizeof(value),
76 BPF_ANY);
77 }
78
79 /*
80 * timerlat_bpf_attach - attach BPF program to collect timerlat data
81 */
82 int timerlat_bpf_attach(void)
83 {
84 debug_msg("Attaching BPF program\n");
85
86 return timerlat_bpf__attach(bpf);
87 }
88
89 /*
90 * timerlat_bpf_detach - detach BPF program to collect timerlat data
91 */
92 void timerlat_bpf_detach(void)
93 {
94 timerlat_bpf__detach(bpf);
95 }
96
97 /*
98 * timerlat_bpf_detach - destroy BPF program to collect timerlat data
99 */
100 void timerlat_bpf_destroy(void)
101 {
102 timerlat_bpf__destroy(bpf);
103 bpf = NULL;
104 if (obj)
105 bpf_object__close(obj);
106 obj = NULL;
107 prog = NULL;
108 }
109
110 static int handle_rb_event(void *ctx, void *data, size_t data_sz)
111 {
112 return 0;
113 }
114
115 /*
116 * timerlat_bpf_wait - wait until tracing is stopped or signal
117 */
118 int timerlat_bpf_wait(int timeout)
119 {
120 struct ring_buffer *rb;
121 int retval;
122
123 rb = ring_buffer__new(bpf_map__fd(bpf->maps.signal_stop_tracing),
124 handle_rb_event, NULL, NULL);
125 retval = ring_buffer__poll(rb, timeout * 1000);
126 ring_buffer__free(rb);
127
128 return retval;
129 }
130
131 /*
132 * timerlat_bpf_restart_tracing - restart stopped tracing
133 */
134 int timerlat_bpf_restart_tracing(void)
135 {
136 unsigned int key = 0;
137 unsigned long long value = 0;
138
139 return bpf_map__update_elem(bpf->maps.stop_tracing,
140 &key, sizeof(key),
141 &value, sizeof(value), BPF_ANY);
142 }
143
144 static int get_value(struct bpf_map *map_irq,
145 struct bpf_map *map_thread,
146 struct bpf_map *map_user,
147 int key,
148 long long *value_irq,
149 long long *value_thread,
150 long long *value_user,
151 int cpus)
152 {
153 int err;
154
155 err = bpf_map__lookup_elem(map_irq, &key,
156 sizeof(unsigned int), value_irq,
157 sizeof(long long) * cpus, 0);
158 if (err)
159 return err;
160 err = bpf_map__lookup_elem(map_thread, &key,
161 sizeof(unsigned int), value_thread,
162 sizeof(long long) * cpus, 0);
163 if (err)
164 return err;
165 err = bpf_map__lookup_elem(map_user, &key,
166 sizeof(unsigned int), value_user,
167 sizeof(long long) * cpus, 0);
168 if (err)
169 return err;
170 return 0;
171 }
172
173 /*
174 * timerlat_bpf_get_hist_value - get value from BPF hist map
175 */
176 int timerlat_bpf_get_hist_value(int key,
177 long long *value_irq,
178 long long *value_thread,
179 long long *value_user,
180 int cpus)
181 {
182 return get_value(bpf->maps.hist_irq,
183 bpf->maps.hist_thread,
184 bpf->maps.hist_user,
185 key, value_irq, value_thread, value_user, cpus);
186 }
187
188 /*
189 * timerlat_bpf_get_summary_value - get value from BPF summary map
190 */
191 int timerlat_bpf_get_summary_value(enum summary_field key,
192 long long *value_irq,
193 long long *value_thread,
194 long long *value_user,
195 int cpus)
196 {
197 return get_value(bpf->maps.summary_irq,
198 bpf->maps.summary_thread,
199 bpf->maps.summary_user,
200 key, value_irq, value_thread, value_user, cpus);
201 }
202
203 /*
204 * timerlat_load_bpf_action_program - load and register a BPF action program
205 */
206 int timerlat_load_bpf_action_program(const char *program_path)
207 {
208 int err;
209
210 obj = bpf_object__open_file(program_path, NULL);
211 if (!obj) {
212 err_msg("Failed to open BPF action program: %s\n", program_path);
213 goto out_err;
214 }
215
216 err = bpf_object__load(obj);
217 if (err) {
218 err_msg("Failed to load BPF action program: %s\n", program_path);
219 goto out_obj_err;
220 }
221
222 prog = bpf_object__find_program_by_name(obj, "action_handler");
223 if (!prog) {
224 err_msg("BPF action program must have 'action_handler' function: %s\n",
225 program_path);
226 goto out_obj_err;
227 }
228
229 err = timerlat_bpf_set_action(prog);
230 if (err) {
231 err_msg("Failed to register BPF action program: %s\n", program_path);
232 goto out_prog_err;
233 }
234
235 return 0;
236
237 out_prog_err:
238 prog = NULL;
239 out_obj_err:
240 bpf_object__close(obj);
241 obj = NULL;
242 out_err:
243 return 1;
244 }
245
246 #endif /* HAVE_BPF_SKEL */