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 
31 static unsigned int iterations = 100;
32 static unsigned int nr_mmaps   = 100;
33 static unsigned int nr_samples = 100;  /* samples per mmap */
34 
35 static u64 bench_sample_type;
36 static u16 bench_id_hdr_size;
37 
38 struct bench_data {
39 	int			pid;
40 	int			input_pipe[2];
41 	int			output_pipe[2];
42 	pthread_t		th;
43 };
44 
45 struct bench_dso {
46 	struct list_head	list;
47 	char			*name;
48 	int			ino;
49 };
50 
51 static int nr_dsos;
52 static struct bench_dso *dsos;
53 
54 extern int cmd_inject(int argc, const char *argv[]);
55 
56 static 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 
68 static 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  */
78 static 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 
104 static 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 
118 static 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 */
131 static u64 dso_map_addr(struct bench_dso *dso)
132 {
133 	return 0x400000ULL + dso->ino * 8192ULL;
134 }
135 
136 static 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 
154 static 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 
172 static 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 
218 static 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 
237 static 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 
247 static 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 
275 static 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 
347 static 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 
394 static 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 
449 static 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 
472 int 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 
485