1// SPDX-License-Identifier: GPL-2.0
2#include <inttypes.h>
3#include <unistd.h>
4#include <sys/syscall.h>
5#include <sys/types.h>
6#include <sys/mman.h>
7#include <pthread.h>
8#include <stdlib.h>
9#include <stdio.h>
10#include "debug.h"
11#include "event.h"
12#include "tests.h"
13#include "machine.h"
14#include "thread_map.h"
15#include "map.h"
16#include "symbol.h"
17#include "util/synthetic-events.h"
18#include "thread.h"
19#include <internal/lib.h> // page_size
20
21#define THREADS 4
22
23static int go_away;
24
25struct thread_data {
26	pthread_t	pt;
27	pid_t		tid;
28	void		*map;
29	int		ready[2];
30};
31
32static struct thread_data threads[THREADS];
33
34static int thread_init(struct thread_data *td)
35{
36	void *map;
37
38	map = mmap(NULL, page_size,
39		   PROT_READ|PROT_WRITE|PROT_EXEC,
40		   MAP_SHARED|MAP_ANONYMOUS, -1, 0);
41
42	if (map == MAP_FAILED) {
43		perror("mmap failed");
44		return -1;
45	}
46
47	td->map = map;
48	td->tid = syscall(SYS_gettid);
49
50	pr_debug("tid = %d, map = %p\n", td->tid, map);
51	return 0;
52}
53
54static void *thread_fn(void *arg)
55{
56	struct thread_data *td = arg;
57	ssize_t ret;
58	int go = 0;
59
60	if (thread_init(td))
61		return NULL;
62
63	/* Signal thread_create thread is initialized. */
64	ret = write(td->ready[1], &go, sizeof(int));
65	if (ret != sizeof(int)) {
66		pr_err("failed to notify\n");
67		return NULL;
68	}
69
70	while (!go_away) {
71		/* Waiting for main thread to kill us. */
72		usleep(100);
73	}
74
75	munmap(td->map, page_size);
76	return NULL;
77}
78
79static int thread_create(int i)
80{
81	struct thread_data *td = &threads[i];
82	int err, go;
83
84	if (pipe(td->ready))
85		return -1;
86
87	err = pthread_create(&td->pt, NULL, thread_fn, td);
88	if (!err) {
89		/* Wait for thread initialization. */
90		ssize_t ret = read(td->ready[0], &go, sizeof(int));
91		err = ret != sizeof(int);
92	}
93
94	close(td->ready[0]);
95	close(td->ready[1]);
96	return err;
97}
98
99static int threads_create(void)
100{
101	struct thread_data *td0 = &threads[0];
102	int i, err = 0;
103
104	go_away = 0;
105
106	/* 0 is main thread */
107	if (thread_init(td0))
108		return -1;
109
110	for (i = 1; !err && i < THREADS; i++)
111		err = thread_create(i);
112
113	return err;
114}
115
116static int threads_destroy(void)
117{
118	struct thread_data *td0 = &threads[0];
119	int i, err = 0;
120
121	/* cleanup the main thread */
122	munmap(td0->map, page_size);
123
124	go_away = 1;
125
126	for (i = 1; !err && i < THREADS; i++)
127		err = pthread_join(threads[i].pt, NULL);
128
129	return err;
130}
131
132typedef int (*synth_cb)(struct machine *machine);
133
134static int synth_all(struct machine *machine)
135{
136	return perf_event__synthesize_threads(NULL,
137					      perf_event__process,
138					      machine, 1, 0, 1);
139}
140
141static int synth_process(struct machine *machine)
142{
143	struct perf_thread_map *map;
144	int err;
145
146	map = thread_map__new_by_pid(getpid());
147
148	err = perf_event__synthesize_thread_map(NULL, map,
149						perf_event__process,
150						machine, 1, 0);
151
152	perf_thread_map__put(map);
153	return err;
154}
155
156static int mmap_events(synth_cb synth)
157{
158	struct machine *machine;
159	int err, i;
160
161	/*
162	 * The threads_create will not return before all threads
163	 * are spawned and all created memory map.
164	 *
165	 * They will loop until threads_destroy is called, so we
166	 * can safely run synthesizing function.
167	 */
168	TEST_ASSERT_VAL("failed to create threads", !threads_create());
169
170	machine = machine__new_host();
171
172	dump_trace = verbose > 1 ? 1 : 0;
173
174	err = synth(machine);
175
176	dump_trace = 0;
177
178	TEST_ASSERT_VAL("failed to destroy threads", !threads_destroy());
179	TEST_ASSERT_VAL("failed to synthesize maps", !err);
180
181	/*
182	 * All data is synthesized, try to find map for each
183	 * thread object.
184	 */
185	for (i = 0; i < THREADS; i++) {
186		struct thread_data *td = &threads[i];
187		struct addr_location al;
188		struct thread *thread;
189
190		addr_location__init(&al);
191		thread = machine__findnew_thread(machine, getpid(), td->tid);
192
193		pr_debug("looking for map %p\n", td->map);
194
195		thread__find_map(thread, PERF_RECORD_MISC_USER,
196				 (unsigned long) (td->map + 1), &al);
197
198		thread__put(thread);
199
200		if (!al.map) {
201			pr_debug("failed, couldn't find map\n");
202			err = -1;
203			addr_location__exit(&al);
204			break;
205		}
206
207		pr_debug("map %p, addr %" PRIx64 "\n", al.map, map__start(al.map));
208		addr_location__exit(&al);
209	}
210
211	machine__delete(machine);
212	return err;
213}
214
215/*
216 * This test creates 'THREADS' number of threads (including
217 * main thread) and each thread creates memory map.
218 *
219 * When threads are created, we synthesize them with both
220 * (separate tests):
221 *   perf_event__synthesize_thread_map (process based)
222 *   perf_event__synthesize_threads    (global)
223 *
224 * We test we can find all memory maps via:
225 *   thread__find_map
226 *
227 * by using all thread objects.
228 */
229static int test__mmap_thread_lookup(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
230{
231	/* perf_event__synthesize_threads synthesize */
232	TEST_ASSERT_VAL("failed with sythesizing all",
233			!mmap_events(synth_all));
234
235	/* perf_event__synthesize_thread_map synthesize */
236	TEST_ASSERT_VAL("failed with sythesizing process",
237			!mmap_events(synth_process));
238
239	return 0;
240}
241
242DEFINE_SUITE("Lookup mmap thread", mmap_thread_lookup);
243