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 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 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. */ 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 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 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 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 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 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. */ 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. */ 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 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 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