1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <stdlib.h> |
3 | #include <stddef.h> |
4 | #include <ftw.h> |
5 | #include <fcntl.h> |
6 | #include <errno.h> |
7 | #include <unistd.h> |
8 | #include <pthread.h> |
9 | #include <sys/mman.h> |
10 | #include <sys/wait.h> |
11 | #include <linux/kernel.h> |
12 | #include <linux/time64.h> |
13 | #include <linux/list.h> |
14 | #include <linux/err.h> |
15 | #include <linux/zalloc.h> |
16 | #include <internal/lib.h> |
17 | #include <subcmd/parse-options.h> |
18 | |
19 | #include "bench.h" |
20 | #include "util/data.h" |
21 | #include "util/stat.h" |
22 | #include "util/debug.h" |
23 | #include "util/symbol.h" |
24 | #include "util/session.h" |
25 | #include "util/build-id.h" |
26 | #include "util/sample.h" |
27 | #include "util/synthetic-events.h" |
28 | |
29 | #define MMAP_DEV_MAJOR 8 |
30 | #define DSO_MMAP_RATIO 4 |
31 | |
32 | static unsigned int iterations = 100; |
33 | static unsigned int nr_mmaps = 100; |
34 | static unsigned int nr_samples = 100; /* samples per mmap */ |
35 | |
36 | static u64 bench_sample_type; |
37 | static u16 bench_id_hdr_size; |
38 | |
39 | struct bench_data { |
40 | int pid; |
41 | int input_pipe[2]; |
42 | int output_pipe[2]; |
43 | pthread_t th; |
44 | }; |
45 | |
46 | struct bench_dso { |
47 | struct list_head list; |
48 | char *name; |
49 | int ino; |
50 | }; |
51 | |
52 | static int nr_dsos; |
53 | static struct bench_dso *dsos; |
54 | |
55 | extern int cmd_inject(int argc, const char *argv[]); |
56 | |
57 | static const struct option options[] = { |
58 | OPT_UINTEGER('i', "iterations" , &iterations, |
59 | "Number of iterations used to compute average (default: 100)" ), |
60 | OPT_UINTEGER('m', "nr-mmaps" , &nr_mmaps, |
61 | "Number of mmap events for each iteration (default: 100)" ), |
62 | OPT_UINTEGER('n', "nr-samples" , &nr_samples, |
63 | "Number of sample events per mmap event (default: 100)" ), |
64 | OPT_INCR('v', "verbose" , &verbose, |
65 | "be more verbose (show iteration count, DSO name, etc)" ), |
66 | OPT_END() |
67 | }; |
68 | |
69 | static const char *const bench_usage[] = { |
70 | "perf bench internals inject-build-id <options>" , |
71 | NULL |
72 | }; |
73 | |
74 | /* |
75 | * Helper for collect_dso that adds the given file as a dso to dso_list |
76 | * if it contains a build-id. Stops after collecting 4 times more than |
77 | * we need (for MMAP2 events). |
78 | */ |
79 | static int add_dso(const char *fpath, const struct stat *sb __maybe_unused, |
80 | int typeflag, struct FTW *ftwbuf __maybe_unused) |
81 | { |
82 | struct bench_dso *dso = &dsos[nr_dsos]; |
83 | struct build_id bid; |
84 | |
85 | if (typeflag == FTW_D || typeflag == FTW_SL) |
86 | return 0; |
87 | |
88 | if (filename__read_build_id(fpath, &bid) < 0) |
89 | return 0; |
90 | |
91 | dso->name = realpath(fpath, NULL); |
92 | if (dso->name == NULL) |
93 | return -1; |
94 | |
95 | dso->ino = nr_dsos++; |
96 | pr_debug2(" Adding DSO: %s\n" , fpath); |
97 | |
98 | /* stop if we collected enough DSOs */ |
99 | if ((unsigned int)nr_dsos == DSO_MMAP_RATIO * nr_mmaps) |
100 | return 1; |
101 | |
102 | return 0; |
103 | } |
104 | |
105 | static void collect_dso(void) |
106 | { |
107 | dsos = calloc(nr_mmaps * DSO_MMAP_RATIO, sizeof(*dsos)); |
108 | if (dsos == NULL) { |
109 | printf(" Memory allocation failed\n" ); |
110 | exit(1); |
111 | } |
112 | |
113 | if (nftw("/usr/lib/" , add_dso, 10, FTW_PHYS) < 0) |
114 | return; |
115 | |
116 | pr_debug(" Collected %d DSOs\n" , nr_dsos); |
117 | } |
118 | |
119 | static void release_dso(void) |
120 | { |
121 | int i; |
122 | |
123 | for (i = 0; i < nr_dsos; i++) { |
124 | struct bench_dso *dso = &dsos[i]; |
125 | |
126 | zfree(&dso->name); |
127 | } |
128 | free(dsos); |
129 | } |
130 | |
131 | /* Fake address used by mmap and sample events */ |
132 | static u64 dso_map_addr(struct bench_dso *dso) |
133 | { |
134 | return 0x400000ULL + dso->ino * 8192ULL; |
135 | } |
136 | |
137 | static ssize_t synthesize_attr(struct bench_data *data) |
138 | { |
139 | union perf_event event; |
140 | |
141 | memset(&event, 0, sizeof(event.attr) + sizeof(u64)); |
142 | |
143 | event.header.type = PERF_RECORD_HEADER_ATTR; |
144 | event.header.size = sizeof(event.attr) + sizeof(u64); |
145 | |
146 | event.attr.attr.type = PERF_TYPE_SOFTWARE; |
147 | event.attr.attr.config = PERF_COUNT_SW_TASK_CLOCK; |
148 | event.attr.attr.exclude_kernel = 1; |
149 | event.attr.attr.sample_id_all = 1; |
150 | event.attr.attr.sample_type = bench_sample_type; |
151 | |
152 | return writen(data->input_pipe[1], &event, event.header.size); |
153 | } |
154 | |
155 | static ssize_t synthesize_fork(struct bench_data *data) |
156 | { |
157 | union perf_event event; |
158 | |
159 | memset(&event, 0, sizeof(event.fork) + bench_id_hdr_size); |
160 | |
161 | event.header.type = PERF_RECORD_FORK; |
162 | event.header.misc = PERF_RECORD_MISC_FORK_EXEC; |
163 | event.header.size = sizeof(event.fork) + bench_id_hdr_size; |
164 | |
165 | event.fork.ppid = 1; |
166 | event.fork.ptid = 1; |
167 | event.fork.pid = data->pid; |
168 | event.fork.tid = data->pid; |
169 | |
170 | return writen(data->input_pipe[1], &event, event.header.size); |
171 | } |
172 | |
173 | static ssize_t synthesize_mmap(struct bench_data *data, struct bench_dso *dso, u64 timestamp) |
174 | { |
175 | union perf_event event; |
176 | size_t len = offsetof(struct perf_record_mmap2, filename); |
177 | u64 *id_hdr_ptr = (void *)&event; |
178 | int ts_idx; |
179 | |
180 | len += roundup(strlen(dso->name) + 1, 8) + bench_id_hdr_size; |
181 | |
182 | memset(&event, 0, min(len, sizeof(event.mmap2))); |
183 | |
184 | event.header.type = PERF_RECORD_MMAP2; |
185 | event.header.misc = PERF_RECORD_MISC_USER; |
186 | event.header.size = len; |
187 | |
188 | event.mmap2.pid = data->pid; |
189 | event.mmap2.tid = data->pid; |
190 | event.mmap2.maj = MMAP_DEV_MAJOR; |
191 | event.mmap2.ino = dso->ino; |
192 | |
193 | strcpy(event.mmap2.filename, dso->name); |
194 | |
195 | event.mmap2.start = dso_map_addr(dso); |
196 | event.mmap2.len = 4096; |
197 | event.mmap2.prot = PROT_EXEC; |
198 | |
199 | if (len > sizeof(event.mmap2)) { |
200 | /* write mmap2 event first */ |
201 | if (writen(data->input_pipe[1], &event, len - bench_id_hdr_size) < 0) |
202 | return -1; |
203 | /* zero-fill sample id header */ |
204 | memset(id_hdr_ptr, 0, bench_id_hdr_size); |
205 | /* put timestamp in the right position */ |
206 | ts_idx = (bench_id_hdr_size / sizeof(u64)) - 2; |
207 | id_hdr_ptr[ts_idx] = timestamp; |
208 | if (writen(data->input_pipe[1], id_hdr_ptr, bench_id_hdr_size) < 0) |
209 | return -1; |
210 | |
211 | return len; |
212 | } |
213 | |
214 | ts_idx = (len / sizeof(u64)) - 2; |
215 | id_hdr_ptr[ts_idx] = timestamp; |
216 | return writen(data->input_pipe[1], &event, len); |
217 | } |
218 | |
219 | static ssize_t synthesize_sample(struct bench_data *data, struct bench_dso *dso, u64 timestamp) |
220 | { |
221 | union perf_event event; |
222 | struct perf_sample sample = { |
223 | .tid = data->pid, |
224 | .pid = data->pid, |
225 | .ip = dso_map_addr(dso), |
226 | .time = timestamp, |
227 | }; |
228 | |
229 | event.header.type = PERF_RECORD_SAMPLE; |
230 | event.header.misc = PERF_RECORD_MISC_USER; |
231 | event.header.size = perf_event__sample_event_size(&sample, bench_sample_type, 0); |
232 | |
233 | perf_event__synthesize_sample(&event, bench_sample_type, 0, &sample); |
234 | |
235 | return writen(data->input_pipe[1], &event, event.header.size); |
236 | } |
237 | |
238 | static ssize_t synthesize_flush(struct bench_data *data) |
239 | { |
240 | struct = { |
241 | .size = sizeof(header), |
242 | .type = PERF_RECORD_FINISHED_ROUND, |
243 | }; |
244 | |
245 | return writen(data->input_pipe[1], &header, header.size); |
246 | } |
247 | |
248 | static void *data_reader(void *arg) |
249 | { |
250 | struct bench_data *data = arg; |
251 | char buf[8192]; |
252 | int flag; |
253 | int n; |
254 | |
255 | flag = fcntl(data->output_pipe[0], F_GETFL); |
256 | fcntl(data->output_pipe[0], F_SETFL, flag | O_NONBLOCK); |
257 | |
258 | /* read out data from child */ |
259 | while (true) { |
260 | n = read(data->output_pipe[0], buf, sizeof(buf)); |
261 | if (n > 0) |
262 | continue; |
263 | if (n == 0) |
264 | break; |
265 | |
266 | if (errno != EINTR && errno != EAGAIN) |
267 | break; |
268 | |
269 | usleep(100); |
270 | } |
271 | |
272 | close(data->output_pipe[0]); |
273 | return NULL; |
274 | } |
275 | |
276 | static int setup_injection(struct bench_data *data, bool build_id_all) |
277 | { |
278 | int ready_pipe[2]; |
279 | int dev_null_fd; |
280 | char buf; |
281 | |
282 | if (pipe(ready_pipe) < 0) |
283 | return -1; |
284 | |
285 | if (pipe(data->input_pipe) < 0) |
286 | return -1; |
287 | |
288 | if (pipe(data->output_pipe) < 0) |
289 | return -1; |
290 | |
291 | data->pid = fork(); |
292 | if (data->pid < 0) |
293 | return -1; |
294 | |
295 | if (data->pid == 0) { |
296 | const char **inject_argv; |
297 | int inject_argc = 2; |
298 | |
299 | close(data->input_pipe[1]); |
300 | close(data->output_pipe[0]); |
301 | close(ready_pipe[0]); |
302 | |
303 | dup2(data->input_pipe[0], STDIN_FILENO); |
304 | close(data->input_pipe[0]); |
305 | dup2(data->output_pipe[1], STDOUT_FILENO); |
306 | close(data->output_pipe[1]); |
307 | |
308 | dev_null_fd = open("/dev/null" , O_WRONLY); |
309 | if (dev_null_fd < 0) |
310 | exit(1); |
311 | |
312 | dup2(dev_null_fd, STDERR_FILENO); |
313 | |
314 | if (build_id_all) |
315 | inject_argc++; |
316 | |
317 | inject_argv = calloc(inject_argc + 1, sizeof(*inject_argv)); |
318 | if (inject_argv == NULL) |
319 | exit(1); |
320 | |
321 | inject_argv[0] = strdup("inject" ); |
322 | inject_argv[1] = strdup("-b" ); |
323 | if (build_id_all) |
324 | inject_argv[2] = strdup("--buildid-all" ); |
325 | |
326 | /* signal that we're ready to go */ |
327 | close(ready_pipe[1]); |
328 | |
329 | cmd_inject(argc: inject_argc, argv: inject_argv); |
330 | |
331 | exit(0); |
332 | } |
333 | |
334 | pthread_create(&data->th, NULL, data_reader, data); |
335 | |
336 | close(ready_pipe[1]); |
337 | close(data->input_pipe[0]); |
338 | close(data->output_pipe[1]); |
339 | |
340 | /* wait for child ready */ |
341 | if (read(ready_pipe[0], &buf, 1) < 0) |
342 | return -1; |
343 | close(ready_pipe[0]); |
344 | |
345 | return 0; |
346 | } |
347 | |
348 | static int inject_build_id(struct bench_data *data, u64 *) |
349 | { |
350 | int status; |
351 | unsigned int i, k; |
352 | struct rusage rusage; |
353 | |
354 | /* this makes the child to run */ |
355 | if (perf_header__write_pipe(data->input_pipe[1]) < 0) |
356 | return -1; |
357 | |
358 | if (synthesize_attr(data) < 0) |
359 | return -1; |
360 | |
361 | if (synthesize_fork(data) < 0) |
362 | return -1; |
363 | |
364 | for (i = 0; i < nr_mmaps; i++) { |
365 | int idx = rand() % (nr_dsos - 1); |
366 | struct bench_dso *dso = &dsos[idx]; |
367 | u64 timestamp = rand() % 1000000; |
368 | |
369 | pr_debug2(" [%d] injecting: %s\n" , i+1, dso->name); |
370 | if (synthesize_mmap(data, dso, timestamp) < 0) |
371 | return -1; |
372 | |
373 | for (k = 0; k < nr_samples; k++) { |
374 | if (synthesize_sample(data, dso, timestamp: timestamp + k * 1000) < 0) |
375 | return -1; |
376 | } |
377 | |
378 | if ((i + 1) % 10 == 0) { |
379 | if (synthesize_flush(data) < 0) |
380 | return -1; |
381 | } |
382 | } |
383 | |
384 | /* this makes the child to finish */ |
385 | close(data->input_pipe[1]); |
386 | |
387 | wait4(data->pid, &status, 0, &rusage); |
388 | *max_rss = rusage.ru_maxrss; |
389 | |
390 | pr_debug(" Child %d exited with %d\n" , data->pid, status); |
391 | |
392 | return 0; |
393 | } |
394 | |
395 | static void do_inject_loop(struct bench_data *data, bool build_id_all) |
396 | { |
397 | unsigned int i; |
398 | struct stats time_stats, mem_stats; |
399 | double time_average, time_stddev; |
400 | double mem_average, mem_stddev; |
401 | |
402 | init_stats(&time_stats); |
403 | init_stats(&mem_stats); |
404 | |
405 | pr_debug(" Build-id%s injection benchmark\n" , build_id_all ? "-all" : "" ); |
406 | |
407 | for (i = 0; i < iterations; i++) { |
408 | struct timeval start, end, diff; |
409 | u64 runtime_us, ; |
410 | |
411 | pr_debug(" Iteration #%d\n" , i+1); |
412 | |
413 | if (setup_injection(data, build_id_all) < 0) { |
414 | printf(" Build-id injection setup failed\n" ); |
415 | break; |
416 | } |
417 | |
418 | gettimeofday(&start, NULL); |
419 | if (inject_build_id(data, max_rss: &max_rss) < 0) { |
420 | printf(" Build-id injection failed\n" ); |
421 | break; |
422 | } |
423 | |
424 | gettimeofday(&end, NULL); |
425 | timersub(&end, &start, &diff); |
426 | runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec; |
427 | update_stats(&time_stats, runtime_us); |
428 | update_stats(&mem_stats, max_rss); |
429 | |
430 | pthread_join(data->th, NULL); |
431 | } |
432 | |
433 | time_average = avg_stats(&time_stats) / USEC_PER_MSEC; |
434 | time_stddev = stddev_stats(&time_stats) / USEC_PER_MSEC; |
435 | printf(" Average build-id%s injection took: %.3f msec (+- %.3f msec)\n" , |
436 | build_id_all ? "-all" : "" , time_average, time_stddev); |
437 | |
438 | /* each iteration, it processes MMAP2 + BUILD_ID + nr_samples * SAMPLE */ |
439 | time_average = avg_stats(&time_stats) / (nr_mmaps * (nr_samples + 2)); |
440 | time_stddev = stddev_stats(&time_stats) / (nr_mmaps * (nr_samples + 2)); |
441 | printf(" Average time per event: %.3f usec (+- %.3f usec)\n" , |
442 | time_average, time_stddev); |
443 | |
444 | mem_average = avg_stats(&mem_stats); |
445 | mem_stddev = stddev_stats(&mem_stats); |
446 | printf(" Average memory usage: %.0f KB (+- %.0f KB)\n" , |
447 | mem_average, mem_stddev); |
448 | } |
449 | |
450 | static int do_inject_loops(struct bench_data *data) |
451 | { |
452 | |
453 | srand(time(NULL)); |
454 | symbol__init(NULL); |
455 | |
456 | bench_sample_type = PERF_SAMPLE_IDENTIFIER | PERF_SAMPLE_IP; |
457 | bench_sample_type |= PERF_SAMPLE_TID | PERF_SAMPLE_TIME; |
458 | bench_id_hdr_size = 32; |
459 | |
460 | collect_dso(); |
461 | if (nr_dsos == 0) { |
462 | printf(" Cannot collect DSOs for injection\n" ); |
463 | return -1; |
464 | } |
465 | |
466 | do_inject_loop(data, build_id_all: false); |
467 | do_inject_loop(data, build_id_all: true); |
468 | |
469 | release_dso(); |
470 | return 0; |
471 | } |
472 | |
473 | int bench_inject_build_id(int argc, const char **argv) |
474 | { |
475 | struct bench_data data; |
476 | |
477 | argc = parse_options(argc, argv, options, bench_usage, 0); |
478 | if (argc) { |
479 | usage_with_options(bench_usage, options); |
480 | exit(EXIT_FAILURE); |
481 | } |
482 | |
483 | return do_inject_loops(data: &data); |
484 | } |
485 | |
486 | |