1 /*
2 * Linux perf perf-<pid>.map and jit-<pid>.dump integration.
3 *
4 * The jitdump spec can be found at [1].
5 *
6 * [1] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/tools/perf/Documentation/jitdump-specification.txt
7 *
8 * SPDX-License-Identifier: GPL-2.0-or-later
9 */
10
11 #include "qemu/osdep.h"
12 #include "elf.h"
13 #include "exec/target_page.h"
14 #include "exec/translation-block.h"
15 #include "qemu/timer.h"
16 #include "tcg/debuginfo.h"
17 #include "tcg/perf.h"
18 #include "tcg/tcg.h"
19
safe_fopen_w(const char * path)20 static FILE *safe_fopen_w(const char *path)
21 {
22 int saved_errno;
23 FILE *f;
24 int fd;
25
26 /* Delete the old file, if any. */
27 unlink(path);
28
29 /* Avoid symlink attacks by using O_CREAT | O_EXCL. */
30 fd = open(path, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
31 if (fd == -1) {
32 return NULL;
33 }
34
35 /* Convert fd to FILE*. */
36 f = fdopen(fd, "w");
37 if (f == NULL) {
38 saved_errno = errno;
39 close(fd);
40 errno = saved_errno;
41 return NULL;
42 }
43
44 return f;
45 }
46
47 static FILE *perfmap;
48
perf_enable_perfmap(void)49 void perf_enable_perfmap(void)
50 {
51 char map_file[32];
52
53 snprintf(map_file, sizeof(map_file), "/tmp/perf-%d.map", getpid());
54 perfmap = safe_fopen_w(map_file);
55 if (perfmap == NULL) {
56 warn_report("Could not open %s: %s, proceeding without perfmap",
57 map_file, strerror(errno));
58 }
59 }
60
61 /* Get PC and size of code JITed for guest instruction #INSN. */
get_host_pc_size(uintptr_t * host_pc,uint16_t * host_size,const void * start,size_t insn)62 static void get_host_pc_size(uintptr_t *host_pc, uint16_t *host_size,
63 const void *start, size_t insn)
64 {
65 uint16_t start_off = insn ? tcg_ctx->gen_insn_end_off[insn - 1] : 0;
66
67 if (host_pc) {
68 *host_pc = (uintptr_t)start + start_off;
69 }
70 if (host_size) {
71 *host_size = tcg_ctx->gen_insn_end_off[insn] - start_off;
72 }
73 }
74
pretty_symbol(const struct debuginfo_query * q,size_t * len)75 static const char *pretty_symbol(const struct debuginfo_query *q, size_t *len)
76 {
77 static __thread char buf[64];
78 int tmp;
79
80 if (!q->symbol) {
81 tmp = snprintf(buf, sizeof(buf), "guest-0x%"PRIx64, q->address);
82 if (len) {
83 *len = MIN(tmp + 1, sizeof(buf));
84 }
85 return buf;
86 }
87
88 if (!q->offset) {
89 if (len) {
90 *len = strlen(q->symbol) + 1;
91 }
92 return q->symbol;
93 }
94
95 tmp = snprintf(buf, sizeof(buf), "%s+0x%"PRIx64, q->symbol, q->offset);
96 if (len) {
97 *len = MIN(tmp + 1, sizeof(buf));
98 }
99 return buf;
100 }
101
write_perfmap_entry(const void * start,size_t insn,const struct debuginfo_query * q)102 static void write_perfmap_entry(const void *start, size_t insn,
103 const struct debuginfo_query *q)
104 {
105 uint16_t host_size;
106 uintptr_t host_pc;
107
108 get_host_pc_size(&host_pc, &host_size, start, insn);
109 fprintf(perfmap, "%"PRIxPTR" %"PRIx16" %s\n",
110 host_pc, host_size, pretty_symbol(q, NULL));
111 }
112
113 static FILE *jitdump;
114 static size_t perf_marker_size;
115 static void *perf_marker = MAP_FAILED;
116
117 #define JITHEADER_MAGIC 0x4A695444
118 #define JITHEADER_VERSION 1
119
120 struct jitheader {
121 uint32_t magic;
122 uint32_t version;
123 uint32_t total_size;
124 uint32_t elf_mach;
125 uint32_t pad1;
126 uint32_t pid;
127 uint64_t timestamp;
128 uint64_t flags;
129 };
130
131 enum jit_record_type {
132 JIT_CODE_LOAD = 0,
133 JIT_CODE_DEBUG_INFO = 2,
134 };
135
136 struct jr_prefix {
137 uint32_t id;
138 uint32_t total_size;
139 uint64_t timestamp;
140 };
141
142 struct jr_code_load {
143 struct jr_prefix p;
144
145 uint32_t pid;
146 uint32_t tid;
147 uint64_t vma;
148 uint64_t code_addr;
149 uint64_t code_size;
150 uint64_t code_index;
151 };
152
153 struct debug_entry {
154 uint64_t addr;
155 int lineno;
156 int discrim;
157 const char name[];
158 };
159
160 struct jr_code_debug_info {
161 struct jr_prefix p;
162
163 uint64_t code_addr;
164 uint64_t nr_entry;
165 struct debug_entry entries[];
166 };
167
get_e_machine(void)168 static uint32_t get_e_machine(void)
169 {
170 Elf64_Ehdr elf_header;
171 FILE *exe;
172 size_t n;
173
174 QEMU_BUILD_BUG_ON(offsetof(Elf32_Ehdr, e_machine) !=
175 offsetof(Elf64_Ehdr, e_machine));
176
177 exe = fopen("/proc/self/exe", "r");
178 if (exe == NULL) {
179 return EM_NONE;
180 }
181
182 n = fread(&elf_header, sizeof(elf_header), 1, exe);
183 fclose(exe);
184 if (n != 1) {
185 return EM_NONE;
186 }
187
188 return elf_header.e_machine;
189 }
190
perf_enable_jitdump(void)191 void perf_enable_jitdump(void)
192 {
193 struct jitheader header;
194 char jitdump_file[32];
195
196 if (!use_rt_clock) {
197 warn_report("CLOCK_MONOTONIC is not available, proceeding without jitdump");
198 return;
199 }
200
201 snprintf(jitdump_file, sizeof(jitdump_file), "jit-%d.dump", getpid());
202 jitdump = safe_fopen_w(jitdump_file);
203 if (jitdump == NULL) {
204 warn_report("Could not open %s: %s, proceeding without jitdump",
205 jitdump_file, strerror(errno));
206 return;
207 }
208
209 /*
210 * `perf inject` will see that the mapped file name in the corresponding
211 * PERF_RECORD_MMAP or PERF_RECORD_MMAP2 event is of the form jit-%d.dump
212 * and will process it as a jitdump file.
213 */
214 perf_marker_size = qemu_real_host_page_size();
215 perf_marker = mmap(NULL, perf_marker_size, PROT_READ | PROT_EXEC,
216 MAP_PRIVATE, fileno(jitdump), 0);
217 if (perf_marker == MAP_FAILED) {
218 warn_report("Could not map %s: %s, proceeding without jitdump",
219 jitdump_file, strerror(errno));
220 fclose(jitdump);
221 jitdump = NULL;
222 return;
223 }
224
225 header.magic = JITHEADER_MAGIC;
226 header.version = JITHEADER_VERSION;
227 header.total_size = sizeof(header);
228 header.elf_mach = get_e_machine();
229 header.pad1 = 0;
230 header.pid = getpid();
231 header.timestamp = get_clock();
232 header.flags = 0;
233 fwrite(&header, sizeof(header), 1, jitdump);
234 }
235
perf_report_prologue(const void * start,size_t size)236 void perf_report_prologue(const void *start, size_t size)
237 {
238 if (perfmap) {
239 fprintf(perfmap, "%"PRIxPTR" %zx tcg-prologue-buffer\n",
240 (uintptr_t)start, size);
241 }
242 }
243
244 /* Write a JIT_CODE_DEBUG_INFO jitdump entry. */
write_jr_code_debug_info(const void * start,const struct debuginfo_query * q,size_t icount)245 static void write_jr_code_debug_info(const void *start,
246 const struct debuginfo_query *q,
247 size_t icount)
248 {
249 struct jr_code_debug_info rec;
250 struct debug_entry ent;
251 uintptr_t host_pc;
252 int insn;
253
254 /* Write the header. */
255 rec.p.id = JIT_CODE_DEBUG_INFO;
256 rec.p.total_size = sizeof(rec) + sizeof(ent) + 1;
257 rec.p.timestamp = get_clock();
258 rec.code_addr = (uintptr_t)start;
259 rec.nr_entry = 1;
260 for (insn = 0; insn < icount; insn++) {
261 if (q[insn].file) {
262 rec.p.total_size += sizeof(ent) + strlen(q[insn].file) + 1;
263 rec.nr_entry++;
264 }
265 }
266 fwrite(&rec, sizeof(rec), 1, jitdump);
267
268 /* Write the main debug entries. */
269 for (insn = 0; insn < icount; insn++) {
270 if (q[insn].file) {
271 get_host_pc_size(&host_pc, NULL, start, insn);
272 ent.addr = host_pc;
273 ent.lineno = q[insn].line;
274 ent.discrim = 0;
275 fwrite(&ent, sizeof(ent), 1, jitdump);
276 fwrite(q[insn].file, strlen(q[insn].file) + 1, 1, jitdump);
277 }
278 }
279
280 /* Write the trailing debug_entry. */
281 ent.addr = (uintptr_t)start + tcg_ctx->gen_insn_end_off[icount - 1];
282 ent.lineno = 0;
283 ent.discrim = 0;
284 fwrite(&ent, sizeof(ent), 1, jitdump);
285 fwrite("", 1, 1, jitdump);
286 }
287
288 /* Write a JIT_CODE_LOAD jitdump entry. */
write_jr_code_load(const void * start,uint16_t host_size,const struct debuginfo_query * q)289 static void write_jr_code_load(const void *start, uint16_t host_size,
290 const struct debuginfo_query *q)
291 {
292 static uint64_t code_index;
293 struct jr_code_load rec;
294 const char *symbol;
295 size_t symbol_size;
296
297 symbol = pretty_symbol(q, &symbol_size);
298 rec.p.id = JIT_CODE_LOAD;
299 rec.p.total_size = sizeof(rec) + symbol_size + host_size;
300 rec.p.timestamp = get_clock();
301 rec.pid = getpid();
302 rec.tid = qemu_get_thread_id();
303 rec.vma = (uintptr_t)start;
304 rec.code_addr = (uintptr_t)start;
305 rec.code_size = host_size;
306 rec.code_index = code_index++;
307 fwrite(&rec, sizeof(rec), 1, jitdump);
308 fwrite(symbol, symbol_size, 1, jitdump);
309 fwrite(start, host_size, 1, jitdump);
310 }
311
perf_report_code(uint64_t guest_pc,TranslationBlock * tb,const void * start)312 void perf_report_code(uint64_t guest_pc, TranslationBlock *tb,
313 const void *start)
314 {
315 struct debuginfo_query *q;
316 size_t insn, start_words;
317 uint64_t *gen_insn_data;
318
319 if (!perfmap && !jitdump) {
320 return;
321 }
322
323 q = g_try_malloc0_n(tb->icount, sizeof(*q));
324 if (!q) {
325 return;
326 }
327
328 debuginfo_lock();
329
330 /* Query debuginfo for each guest instruction. */
331 gen_insn_data = tcg_ctx->gen_insn_data;
332 start_words = tcg_ctx->insn_start_words;
333
334 for (insn = 0; insn < tb->icount; insn++) {
335 /* FIXME: This replicates the restore_state_to_opc() logic. */
336 q[insn].address = gen_insn_data[insn * start_words + 0];
337 if (tb_cflags(tb) & CF_PCREL) {
338 q[insn].address |= (guest_pc & qemu_target_page_mask());
339 }
340 q[insn].flags = DEBUGINFO_SYMBOL | (jitdump ? DEBUGINFO_LINE : 0);
341 }
342 debuginfo_query(q, tb->icount);
343
344 /* Emit perfmap entries if needed. */
345 if (perfmap) {
346 flockfile(perfmap);
347 for (insn = 0; insn < tb->icount; insn++) {
348 write_perfmap_entry(start, insn, &q[insn]);
349 }
350 funlockfile(perfmap);
351 }
352
353 /* Emit jitdump entries if needed. */
354 if (jitdump) {
355 flockfile(jitdump);
356 write_jr_code_debug_info(start, q, tb->icount);
357 write_jr_code_load(start, tcg_ctx->gen_insn_end_off[tb->icount - 1],
358 q);
359 funlockfile(jitdump);
360 }
361
362 debuginfo_unlock();
363 g_free(q);
364 }
365
perf_exit(void)366 void perf_exit(void)
367 {
368 if (perfmap) {
369 fclose(perfmap);
370 perfmap = NULL;
371 }
372
373 if (perf_marker != MAP_FAILED) {
374 munmap(perf_marker, perf_marker_size);
375 perf_marker = MAP_FAILED;
376 }
377
378 if (jitdump) {
379 fclose(jitdump);
380 jitdump = NULL;
381 }
382 }
383