243 lines · c
1// SPDX-License-Identifier: GPL-2.02#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_size20 21#define THREADS 422 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 threads163 * are spawned and all created memory map.164 *165 * They will loop until threads_destroy is called, so we166 * 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 each183 * 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 (including217 * main thread) and each thread creates memory map.218 *219 * When threads are created, we synthesize them with both220 * (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_map226 *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