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