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
32static unsigned int iterations = 100;
33static unsigned int nr_mmaps   = 100;
34static unsigned int nr_samples = 100;  /* samples per mmap */
35
36static u64 bench_sample_type;
37static u16 bench_id_hdr_size;
38
39struct bench_data {
40	int			pid;
41	int			input_pipe[2];
42	int			output_pipe[2];
43	pthread_t		th;
44};
45
46struct bench_dso {
47	struct list_head	list;
48	char			*name;
49	int			ino;
50};
51
52static int nr_dsos;
53static struct bench_dso *dsos;
54
55extern int cmd_inject(int argc, const char *argv[]);
56
57static 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
69static 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 */
79static 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
105static 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
119static 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 */
132static u64 dso_map_addr(struct bench_dso *dso)
133{
134	return 0x400000ULL + dso->ino * 8192ULL;
135}
136
137static 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
155static 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
173static 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
219static 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
238static 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
248static 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
276static 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
348static 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 - 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 + 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
395static 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
450static 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
473int 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