Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
a43783ae | 2 | #include <errno.h> |
fd20e811 | 3 | #include <inttypes.h> |
1fbe7df8 ACM |
4 | /* For the CLR_() macros */ |
5 | #include <pthread.h> | |
6 | ||
16d00fee JO |
7 | #include <sched.h> |
8 | #include "evlist.h" | |
9 | #include "evsel.h" | |
10 | #include "perf.h" | |
11 | #include "debug.h" | |
12 | #include "tests.h" | |
13 | ||
14 | static int sched__get_first_possible_cpu(pid_t pid, cpu_set_t *maskp) | |
15 | { | |
16 | int i, cpu = -1, nrcpus = 1024; | |
17 | realloc: | |
18 | CPU_ZERO(maskp); | |
19 | ||
20 | if (sched_getaffinity(pid, sizeof(*maskp), maskp) == -1) { | |
21 | if (errno == EINVAL && nrcpus < (1024 << 8)) { | |
22 | nrcpus = nrcpus << 2; | |
23 | goto realloc; | |
24 | } | |
25 | perror("sched_getaffinity"); | |
26 | return -1; | |
27 | } | |
28 | ||
29 | for (i = 0; i < nrcpus; i++) { | |
30 | if (CPU_ISSET(i, maskp)) { | |
31 | if (cpu == -1) | |
32 | cpu = i; | |
33 | else | |
34 | CPU_CLR(i, maskp); | |
35 | } | |
36 | } | |
37 | ||
38 | return cpu; | |
39 | } | |
40 | ||
81f17c90 | 41 | int test__PERF_RECORD(struct test *test __maybe_unused, int subtest __maybe_unused) |
16d00fee | 42 | { |
b4006796 | 43 | struct record_opts opts = { |
16d00fee JO |
44 | .target = { |
45 | .uid = UINT_MAX, | |
46 | .uses_mmap = true, | |
47 | }, | |
509051ea | 48 | .no_buffering = true, |
509051ea | 49 | .mmap_pages = 256, |
16d00fee JO |
50 | }; |
51 | cpu_set_t cpu_mask; | |
52 | size_t cpu_mask_size = sizeof(cpu_mask); | |
63503dba | 53 | struct evlist *evlist = perf_evlist__new_dummy(); |
32dcd021 | 54 | struct evsel *evsel; |
16d00fee JO |
55 | struct perf_sample sample; |
56 | const char *cmd = "sleep"; | |
57 | const char *argv[] = { cmd, "1", NULL, }; | |
5c5e854b | 58 | char *bname, *mmap_filename; |
16d00fee JO |
59 | u64 prev_time = 0; |
60 | bool found_cmd_mmap = false, | |
2aac9f9d | 61 | found_coreutils_mmap = false, |
16d00fee JO |
62 | found_libc_mmap = false, |
63 | found_vdso_mmap = false, | |
64 | found_ld_mmap = false; | |
65 | int err = -1, errs = 0, i, wakeups = 0; | |
66 | u32 cpu; | |
67 | int total_events = 0, nr_events[PERF_RECORD_MAX] = { 0, }; | |
ba3dfff8 | 68 | char sbuf[STRERR_BUFSIZE]; |
16d00fee | 69 | |
69ef8f47 ACM |
70 | if (evlist == NULL) /* Fallback for kernels lacking PERF_COUNT_SW_DUMMY */ |
71 | evlist = perf_evlist__new_default(); | |
72 | ||
9ef6839b | 73 | if (evlist == NULL) { |
16d00fee JO |
74 | pr_debug("Not enough memory to create evlist\n"); |
75 | goto out; | |
76 | } | |
77 | ||
16d00fee JO |
78 | /* |
79 | * Create maps of threads and cpus to monitor. In this case | |
80 | * we start with all threads and cpus (-1, -1) but then in | |
81 | * perf_evlist__prepare_workload we'll fill in the only thread | |
82 | * we're monitoring, the one forked there. | |
83 | */ | |
84 | err = perf_evlist__create_maps(evlist, &opts.target); | |
85 | if (err < 0) { | |
86 | pr_debug("Not enough memory to create thread/cpu maps\n"); | |
87 | goto out_delete_evlist; | |
88 | } | |
89 | ||
90 | /* | |
91 | * Prepare the workload in argv[] to run, it'll fork it, and then wait | |
92 | * for perf_evlist__start_workload() to exec it. This is done this way | |
93 | * so that we have time to open the evlist (calling sys_perf_event_open | |
94 | * on all the fds) and then mmap them. | |
95 | */ | |
735f7e0b | 96 | err = perf_evlist__prepare_workload(evlist, &opts.target, argv, false, NULL); |
16d00fee JO |
97 | if (err < 0) { |
98 | pr_debug("Couldn't run the workload!\n"); | |
03ad9747 | 99 | goto out_delete_evlist; |
16d00fee JO |
100 | } |
101 | ||
102 | /* | |
103 | * Config the evsels, setting attr->comm on the first one, etc. | |
104 | */ | |
105 | evsel = perf_evlist__first(evlist); | |
7be5ebe8 ACM |
106 | perf_evsel__set_sample_bit(evsel, CPU); |
107 | perf_evsel__set_sample_bit(evsel, TID); | |
108 | perf_evsel__set_sample_bit(evsel, TIME); | |
e68ae9cf | 109 | perf_evlist__config(evlist, &opts, NULL); |
16d00fee JO |
110 | |
111 | err = sched__get_first_possible_cpu(evlist->workload.pid, &cpu_mask); | |
112 | if (err < 0) { | |
ba3dfff8 | 113 | pr_debug("sched__get_first_possible_cpu: %s\n", |
c8b5f2c9 | 114 | str_error_r(errno, sbuf, sizeof(sbuf))); |
03ad9747 | 115 | goto out_delete_evlist; |
16d00fee JO |
116 | } |
117 | ||
118 | cpu = err; | |
119 | ||
120 | /* | |
121 | * So that we can check perf_sample.cpu on all the samples. | |
122 | */ | |
123 | if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, &cpu_mask) < 0) { | |
ba3dfff8 | 124 | pr_debug("sched_setaffinity: %s\n", |
c8b5f2c9 | 125 | str_error_r(errno, sbuf, sizeof(sbuf))); |
03ad9747 | 126 | goto out_delete_evlist; |
16d00fee JO |
127 | } |
128 | ||
129 | /* | |
130 | * Call sys_perf_event_open on all the fds on all the evsels, | |
131 | * grouping them if asked to. | |
132 | */ | |
133 | err = perf_evlist__open(evlist); | |
134 | if (err < 0) { | |
ba3dfff8 | 135 | pr_debug("perf_evlist__open: %s\n", |
c8b5f2c9 | 136 | str_error_r(errno, sbuf, sizeof(sbuf))); |
03ad9747 | 137 | goto out_delete_evlist; |
16d00fee JO |
138 | } |
139 | ||
140 | /* | |
141 | * mmap the first fd on a given CPU and ask for events for the other | |
142 | * fds in the same CPU to be injected in the same mmap ring buffer | |
143 | * (using ioctl(PERF_EVENT_IOC_SET_OUTPUT)). | |
144 | */ | |
f74b9d3a | 145 | err = perf_evlist__mmap(evlist, opts.mmap_pages); |
16d00fee | 146 | if (err < 0) { |
ba3dfff8 | 147 | pr_debug("perf_evlist__mmap: %s\n", |
c8b5f2c9 | 148 | str_error_r(errno, sbuf, sizeof(sbuf))); |
f26e1c7c | 149 | goto out_delete_evlist; |
16d00fee JO |
150 | } |
151 | ||
152 | /* | |
153 | * Now that all is properly set up, enable the events, they will | |
154 | * count just on workload.pid, which will start... | |
155 | */ | |
156 | perf_evlist__enable(evlist); | |
157 | ||
158 | /* | |
159 | * Now! | |
160 | */ | |
161 | perf_evlist__start_workload(evlist); | |
162 | ||
163 | while (1) { | |
164 | int before = total_events; | |
165 | ||
166 | for (i = 0; i < evlist->nr_mmaps; i++) { | |
167 | union perf_event *event; | |
88e37a4b | 168 | struct perf_mmap *md; |
16d00fee | 169 | |
88e37a4b | 170 | md = &evlist->mmap[i]; |
b9bae2c8 | 171 | if (perf_mmap__read_init(md) < 0) |
88e37a4b KL |
172 | continue; |
173 | ||
0019dc87 | 174 | while ((event = perf_mmap__read_event(md)) != NULL) { |
16d00fee JO |
175 | const u32 type = event->header.type; |
176 | const char *name = perf_event__name(type); | |
177 | ||
178 | ++total_events; | |
179 | if (type < PERF_RECORD_MAX) | |
180 | nr_events[type]++; | |
181 | ||
182 | err = perf_evlist__parse_sample(evlist, event, &sample); | |
183 | if (err < 0) { | |
bb963e16 | 184 | if (verbose > 0) |
16d00fee JO |
185 | perf_event__fprintf(event, stderr); |
186 | pr_debug("Couldn't parse sample\n"); | |
983874d1 | 187 | goto out_delete_evlist; |
16d00fee JO |
188 | } |
189 | ||
bb963e16 | 190 | if (verbose > 0) { |
16d00fee JO |
191 | pr_info("%" PRIu64" %d ", sample.time, sample.cpu); |
192 | perf_event__fprintf(event, stderr); | |
193 | } | |
194 | ||
195 | if (prev_time > sample.time) { | |
196 | pr_debug("%s going backwards in time, prev=%" PRIu64 ", curr=%" PRIu64 "\n", | |
197 | name, prev_time, sample.time); | |
198 | ++errs; | |
199 | } | |
200 | ||
201 | prev_time = sample.time; | |
202 | ||
203 | if (sample.cpu != cpu) { | |
204 | pr_debug("%s with unexpected cpu, expected %d, got %d\n", | |
205 | name, cpu, sample.cpu); | |
206 | ++errs; | |
207 | } | |
208 | ||
209 | if ((pid_t)sample.pid != evlist->workload.pid) { | |
210 | pr_debug("%s with unexpected pid, expected %d, got %d\n", | |
211 | name, evlist->workload.pid, sample.pid); | |
212 | ++errs; | |
213 | } | |
214 | ||
215 | if ((pid_t)sample.tid != evlist->workload.pid) { | |
216 | pr_debug("%s with unexpected tid, expected %d, got %d\n", | |
217 | name, evlist->workload.pid, sample.tid); | |
218 | ++errs; | |
219 | } | |
220 | ||
221 | if ((type == PERF_RECORD_COMM || | |
222 | type == PERF_RECORD_MMAP || | |
5c5e854b | 223 | type == PERF_RECORD_MMAP2 || |
16d00fee JO |
224 | type == PERF_RECORD_FORK || |
225 | type == PERF_RECORD_EXIT) && | |
226 | (pid_t)event->comm.pid != evlist->workload.pid) { | |
227 | pr_debug("%s with unexpected pid/tid\n", name); | |
228 | ++errs; | |
229 | } | |
230 | ||
231 | if ((type == PERF_RECORD_COMM || | |
5c5e854b SE |
232 | type == PERF_RECORD_MMAP || |
233 | type == PERF_RECORD_MMAP2) && | |
16d00fee JO |
234 | event->comm.pid != event->comm.tid) { |
235 | pr_debug("%s with different pid/tid!\n", name); | |
236 | ++errs; | |
237 | } | |
238 | ||
239 | switch (type) { | |
240 | case PERF_RECORD_COMM: | |
241 | if (strcmp(event->comm.comm, cmd)) { | |
242 | pr_debug("%s with unexpected comm!\n", name); | |
243 | ++errs; | |
244 | } | |
245 | break; | |
246 | case PERF_RECORD_EXIT: | |
247 | goto found_exit; | |
248 | case PERF_RECORD_MMAP: | |
5c5e854b SE |
249 | mmap_filename = event->mmap.filename; |
250 | goto check_bname; | |
251 | case PERF_RECORD_MMAP2: | |
252 | mmap_filename = event->mmap2.filename; | |
253 | check_bname: | |
254 | bname = strrchr(mmap_filename, '/'); | |
16d00fee JO |
255 | if (bname != NULL) { |
256 | if (!found_cmd_mmap) | |
257 | found_cmd_mmap = !strcmp(bname + 1, cmd); | |
2aac9f9d AH |
258 | if (!found_coreutils_mmap) |
259 | found_coreutils_mmap = !strcmp(bname + 1, "coreutils"); | |
16d00fee JO |
260 | if (!found_libc_mmap) |
261 | found_libc_mmap = !strncmp(bname + 1, "libc", 4); | |
262 | if (!found_ld_mmap) | |
263 | found_ld_mmap = !strncmp(bname + 1, "ld", 2); | |
264 | } else if (!found_vdso_mmap) | |
5c5e854b | 265 | found_vdso_mmap = !strcmp(mmap_filename, "[vdso]"); |
16d00fee JO |
266 | break; |
267 | ||
268 | case PERF_RECORD_SAMPLE: | |
269 | /* Just ignore samples for now */ | |
270 | break; | |
271 | default: | |
272 | pr_debug("Unexpected perf_event->header.type %d!\n", | |
273 | type); | |
274 | ++errs; | |
275 | } | |
8e50d384 | 276 | |
d6ace3df | 277 | perf_mmap__consume(md); |
16d00fee | 278 | } |
88e37a4b | 279 | perf_mmap__read_done(md); |
16d00fee JO |
280 | } |
281 | ||
282 | /* | |
283 | * We don't use poll here because at least at 3.1 times the | |
284 | * PERF_RECORD_{!SAMPLE} events don't honour | |
285 | * perf_event_attr.wakeup_events, just PERF_EVENT_SAMPLE does. | |
286 | */ | |
287 | if (total_events == before && false) | |
f66a889d | 288 | perf_evlist__poll(evlist, -1); |
16d00fee JO |
289 | |
290 | sleep(1); | |
291 | if (++wakeups > 5) { | |
292 | pr_debug("No PERF_RECORD_EXIT event!\n"); | |
293 | break; | |
294 | } | |
295 | } | |
296 | ||
297 | found_exit: | |
2aac9f9d | 298 | if (nr_events[PERF_RECORD_COMM] > 1 + !!found_coreutils_mmap) { |
16d00fee JO |
299 | pr_debug("Excessive number of PERF_RECORD_COMM events!\n"); |
300 | ++errs; | |
301 | } | |
302 | ||
303 | if (nr_events[PERF_RECORD_COMM] == 0) { | |
304 | pr_debug("Missing PERF_RECORD_COMM for %s!\n", cmd); | |
305 | ++errs; | |
306 | } | |
307 | ||
2aac9f9d | 308 | if (!found_cmd_mmap && !found_coreutils_mmap) { |
16d00fee JO |
309 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", cmd); |
310 | ++errs; | |
311 | } | |
312 | ||
313 | if (!found_libc_mmap) { | |
314 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", "libc"); | |
315 | ++errs; | |
316 | } | |
317 | ||
318 | if (!found_ld_mmap) { | |
319 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", "ld"); | |
320 | ++errs; | |
321 | } | |
322 | ||
323 | if (!found_vdso_mmap) { | |
324 | pr_debug("PERF_RECORD_MMAP for %s missing!\n", "[vdso]"); | |
325 | ++errs; | |
326 | } | |
16d00fee JO |
327 | out_delete_evlist: |
328 | perf_evlist__delete(evlist); | |
329 | out: | |
330 | return (err < 0 || errs > 0) ? -1 : 0; | |
331 | } |