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