tcg/perf.c

   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 }