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 perf_event_header header = {
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(inject_argc, 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 *max_rss)
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;
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 + 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, max_rss;
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) < 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, false);
467 	do_inject_loop(data, 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);
484 }
485 
486