tools/perf/util/jitdump.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <sys/sysmacros.h>
   3 #include <sys/types.h>
   4 #include <errno.h>
   5 #include <libgen.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <inttypes.h>
  12 #include <byteswap.h>
  13 #include <sys/stat.h>
  14 #include <sys/mman.h>
  15 #include <linux/stringify.h>
  16
  17 #include "util.h"
  18 #include "event.h"
  19 #include "debug.h"
  20 #include "evlist.h"
  21 #include "symbol.h"
  22 #include <elf.h>
  23
  24 #include "tsc.h"
  25 #include "session.h"
  26 #include "jit.h"
  27 #include "jitdump.h"
  28 #include "genelf.h"
  29 #include "../builtin.h"
  30
  31 #include <linux/ctype.h>
  32
  33 struct jit_buf_desc {
  34         struct perf_data *output;
  35         struct perf_session *session;
  36         struct machine *machine;
  37         union jr_entry   *entry;
  38         void             *buf;
  39         uint64_t         sample_type;
  40         size_t           bufsize;
  41         FILE             *in;
  42         bool             needs_bswap; /* handles cross-endianness */
  43         bool             use_arch_timestamp;
  44         void             *debug_data;
  45         void             *unwinding_data;
  46         uint64_t         unwinding_size;
  47         uint64_t         unwinding_mapped_size;
  48         uint64_t         eh_frame_hdr_size;
  49         size_t           nr_debug_entries;
  50         uint32_t         code_load_count;
  51         u64              bytes_written;
  52         struct rb_root   code_root;
  53         char             dir[PATH_MAX];
  54 };
  55
  56 struct debug_line_info {
  57         unsigned long vma;
  58         unsigned int lineno;
  59         /* The filename format is unspecified, absolute path, relative etc. */
  60         char const filename[0];
  61 };
  62
  63 struct jit_tool {
  64         struct perf_tool tool;
  65         struct perf_data        output;
  66         struct perf_data        input;
  67         u64 bytes_written;
  68 };
  69
  70 #define hmax(a, b) ((a) > (b) ? (a) : (b))
  71 #define get_jit_tool(t) (container_of(tool, struct jit_tool, tool))
  72
  73 static int
  74 jit_emit_elf(char *filename,
  75              const char *sym,
  76              uint64_t code_addr,
  77              const void *code,
  78              int csize,
  79              void *debug,
  80              int nr_debug_entries,
  81              void *unwinding,
  82              uint32_t unwinding_header_size,
  83              uint32_t unwinding_size)
  84 {
  85         int ret, fd;
  86
  87         if (verbose > 0)
  88                 fprintf(stderr, "write ELF image %s\n", filename);
  89
  90         fd = open(filename, O_CREAT|O_TRUNC|O_WRONLY, 0644);
  91         if (fd == -1) {
  92                 pr_warning("cannot create jit ELF %s: %s\n", filename, strerror(errno));
  93                 return -1;
  94         }
  95
  96         ret = jit_write_elf(fd, code_addr, sym, (const void *)code, csize, debug, nr_debug_entries,
  97                             unwinding, unwinding_header_size, unwinding_size);
  98
  99         close(fd);
 100
 101         if (ret)
 102                 unlink(filename);
 103
 104         return ret;
 105 }
 106
 107 static void
 108 jit_close(struct jit_buf_desc *jd)
 109 {
 110         if (!(jd && jd->in))
 111                 return;
 112         funlockfile(jd->in);
 113         fclose(jd->in);
 114         jd->in = NULL;
 115 }
 116
 117 static int
 118 jit_validate_events(struct perf_session *session)
 119 {
 120         struct perf_evsel *evsel;
 121
 122         /*
 123          * check that all events use CLOCK_MONOTONIC
 124          */
 125         evlist__for_each_entry(session->evlist, evsel) {
 126                 if (evsel->attr.use_clockid == 0 || evsel->attr.clockid != CLOCK_MONOTONIC)
 127                         return -1;
 128         }
 129         return 0;
 130 }
 131
 132 static int
 133 jit_open(struct jit_buf_desc *jd, const char *name)
 134 {
 135         struct jitheader header;
 136         struct jr_prefix *prefix;
 137         ssize_t bs, bsz = 0;
 138         void *n, *buf = NULL;
 139         int ret, retval = -1;
 140
 141         jd->in = fopen(name, "r");
 142         if (!jd->in)
 143                 return -1;
 144
 145         bsz = hmax(sizeof(header), sizeof(*prefix));
 146
 147         buf = malloc(bsz);
 148         if (!buf)
 149                 goto error;
 150
 151         /*
 152          * protect from writer modifying the file while we are reading it
 153          */
 154         flockfile(jd->in);
 155
 156         ret = fread(buf, sizeof(header), 1, jd->in);
 157         if (ret != 1)
 158                 goto error;
 159
 160         memcpy(&header, buf, sizeof(header));
 161
 162         if (header.magic != JITHEADER_MAGIC) {
 163                 if (header.magic != JITHEADER_MAGIC_SW)
 164                         goto error;
 165                 jd->needs_bswap = true;
 166         }
 167
 168         if (jd->needs_bswap) {
 169                 header.version    = bswap_32(header.version);
 170                 header.total_size = bswap_32(header.total_size);
 171                 header.pid        = bswap_32(header.pid);
 172                 header.elf_mach   = bswap_32(header.elf_mach);
 173                 header.timestamp  = bswap_64(header.timestamp);
 174                 header.flags      = bswap_64(header.flags);
 175         }
 176
 177         jd->use_arch_timestamp = header.flags & JITDUMP_FLAGS_ARCH_TIMESTAMP;
 178
 179         if (verbose > 2)
 180                 pr_debug("version=%u\nhdr.size=%u\nts=0x%llx\npid=%d\nelf_mach=%d\nuse_arch_timestamp=%d\n",
 181                         header.version,
 182                         header.total_size,
 183                         (unsigned long long)header.timestamp,
 184                         header.pid,
 185                         header.elf_mach,
 186                         jd->use_arch_timestamp);
 187
 188         if (header.version > JITHEADER_VERSION) {
 189                 pr_err("wrong jitdump version %u, expected " __stringify(JITHEADER_VERSION),
 190                         header.version);
 191                 goto error;
 192         }
 193
 194         if (header.flags & JITDUMP_FLAGS_RESERVED) {
 195                 pr_err("jitdump file contains invalid or unsupported flags 0x%llx\n",
 196                        (unsigned long long)header.flags & JITDUMP_FLAGS_RESERVED);
 197                 goto error;
 198         }
 199
 200         if (jd->use_arch_timestamp && !jd->session->time_conv.time_mult) {
 201                 pr_err("jitdump file uses arch timestamps but there is no timestamp conversion\n");
 202                 goto error;
 203         }
 204
 205         /*
 206          * validate event is using the correct clockid
 207          */
 208         if (!jd->use_arch_timestamp && jit_validate_events(jd->session)) {
 209                 pr_err("error, jitted code must be sampled with perf record -k 1\n");
 210                 goto error;
 211         }
 212
 213         bs = header.total_size - sizeof(header);
 214
 215         if (bs > bsz) {
 216                 n = realloc(buf, bs);
 217                 if (!n)
 218                         goto error;
 219                 bsz = bs;
 220                 buf = n;
 221                 /* read extra we do not know about */
 222                 ret = fread(buf, bs - bsz, 1, jd->in);
 223                 if (ret != 1)
 224                         goto error;
 225         }
 226         /*
 227          * keep dirname for generating files and mmap records
 228          */
 229         strcpy(jd->dir, name);
 230         dirname(jd->dir);
 231
 232         return 0;
 233 error:
 234         funlockfile(jd->in);
 235         fclose(jd->in);
 236         return retval;
 237 }
 238
 239 static union jr_entry *
 240 jit_get_next_entry(struct jit_buf_desc *jd)
 241 {
 242         struct jr_prefix *prefix;
 243         union jr_entry *jr;
 244         void *addr;
 245         size_t bs, size;
 246         int id, ret;
 247
 248         if (!(jd && jd->in))
 249                 return NULL;
 250
 251         if (jd->buf == NULL) {
 252                 size_t sz = getpagesize();
 253                 if (sz < sizeof(*prefix))
 254                         sz = sizeof(*prefix);
 255
 256                 jd->buf = malloc(sz);
 257                 if (jd->buf == NULL)
 258                         return NULL;
 259
 260                 jd->bufsize = sz;
 261         }
 262
 263         prefix = jd->buf;
 264
 265         /*
 266          * file is still locked at this point
 267          */
 268         ret = fread(prefix, sizeof(*prefix), 1, jd->in);
 269         if (ret  != 1)
 270                 return NULL;
 271
 272         if (jd->needs_bswap) {
 273                 prefix->id         = bswap_32(prefix->id);
 274                 prefix->total_size = bswap_32(prefix->total_size);
 275                 prefix->timestamp  = bswap_64(prefix->timestamp);
 276         }
 277         id   = prefix->id;
 278         size = prefix->total_size;
 279
 280         bs = (size_t)size;
 281         if (bs < sizeof(*prefix))
 282                 return NULL;
 283
 284         if (id >= JIT_CODE_MAX) {
 285                 pr_warning("next_entry: unknown record type %d, skipping\n", id);
 286         }
 287         if (bs > jd->bufsize) {
 288                 void *n;
 289                 n = realloc(jd->buf, bs);
 290                 if (!n)
 291                         return NULL;
 292                 jd->buf = n;
 293                 jd->bufsize = bs;
 294         }
 295
 296         addr = ((void *)jd->buf) + sizeof(*prefix);
 297
 298         ret = fread(addr, bs - sizeof(*prefix), 1, jd->in);
 299         if (ret != 1)
 300                 return NULL;
 301
 302         jr = (union jr_entry *)jd->buf;
 303
 304         switch(id) {
 305         case JIT_CODE_DEBUG_INFO:
 306                 if (jd->needs_bswap) {
 307                         uint64_t n;
 308                         jr->info.code_addr = bswap_64(jr->info.code_addr);
 309                         jr->info.nr_entry  = bswap_64(jr->info.nr_entry);
 310                         for (n = 0 ; n < jr->info.nr_entry; n++) {
 311                                 jr->info.entries[n].addr    = bswap_64(jr->info.entries[n].addr);
 312                                 jr->info.entries[n].lineno  = bswap_32(jr->info.entries[n].lineno);
 313                                 jr->info.entries[n].discrim = bswap_32(jr->info.entries[n].discrim);
 314                         }
 315                 }
 316                 break;
 317         case JIT_CODE_UNWINDING_INFO:
 318                 if (jd->needs_bswap) {
 319                         jr->unwinding.unwinding_size = bswap_64(jr->unwinding.unwinding_size);
 320                         jr->unwinding.eh_frame_hdr_size = bswap_64(jr->unwinding.eh_frame_hdr_size);
 321                         jr->unwinding.mapped_size = bswap_64(jr->unwinding.mapped_size);
 322                 }
 323                 break;
 324         case JIT_CODE_CLOSE:
 325                 break;
 326         case JIT_CODE_LOAD:
 327                 if (jd->needs_bswap) {
 328                         jr->load.pid       = bswap_32(jr->load.pid);
 329                         jr->load.tid       = bswap_32(jr->load.tid);
 330                         jr->load.vma       = bswap_64(jr->load.vma);
 331                         jr->load.code_addr = bswap_64(jr->load.code_addr);
 332                         jr->load.code_size = bswap_64(jr->load.code_size);
 333                         jr->load.code_index= bswap_64(jr->load.code_index);
 334                 }
 335                 jd->code_load_count++;
 336                 break;
 337         case JIT_CODE_MOVE:
 338                 if (jd->needs_bswap) {
 339                         jr->move.pid           = bswap_32(jr->move.pid);
 340                         jr->move.tid           = bswap_32(jr->move.tid);
 341                         jr->move.vma           = bswap_64(jr->move.vma);
 342                         jr->move.old_code_addr = bswap_64(jr->move.old_code_addr);
 343                         jr->move.new_code_addr = bswap_64(jr->move.new_code_addr);
 344                         jr->move.code_size     = bswap_64(jr->move.code_size);
 345                         jr->move.code_index    = bswap_64(jr->move.code_index);
 346                 }
 347                 break;
 348         case JIT_CODE_MAX:
 349         default:
 350                 /* skip unknown record (we have read them) */
 351                 break;
 352         }
 353         return jr;
 354 }
 355
 356 static int
 357 jit_inject_event(struct jit_buf_desc *jd, union perf_event *event)
 358 {
 359         ssize_t size;
 360
 361         size = perf_data__write(jd->output, event, event->header.size);
 362         if (size < 0)
 363                 return -1;
 364
 365         jd->bytes_written += size;
 366         return 0;
 367 }
 368
 369 static uint64_t convert_timestamp(struct jit_buf_desc *jd, uint64_t timestamp)
 370 {
 371         struct perf_tsc_conversion tc;
 372
 373         if (!jd->use_arch_timestamp)
 374                 return timestamp;
 375
 376         tc.time_shift = jd->session->time_conv.time_shift;
 377         tc.time_mult  = jd->session->time_conv.time_mult;
 378         tc.time_zero  = jd->session->time_conv.time_zero;
 379
 380         if (!tc.time_mult)
 381                 return 0;
 382
 383         return tsc_to_perf_time(timestamp, &tc);
 384 }
 385
 386 static int jit_repipe_code_load(struct jit_buf_desc *jd, union jr_entry *jr)
 387 {
 388         struct perf_sample sample;
 389         union perf_event *event;
 390         struct perf_tool *tool = jd->session->tool;
 391         uint64_t code, addr;
 392         uintptr_t uaddr;
 393         char *filename;
 394         struct stat st;
 395         size_t size;
 396         u16 idr_size;
 397         const char *sym;
 398         uint32_t count;
 399         int ret, csize, usize;
 400         pid_t pid, tid;
 401         struct {
 402                 u32 pid, tid;
 403                 u64 time;
 404         } *id;
 405
 406         pid   = jr->load.pid;
 407         tid   = jr->load.tid;
 408         csize = jr->load.code_size;
 409         usize = jd->unwinding_mapped_size;
 410         addr  = jr->load.code_addr;
 411         sym   = (void *)((unsigned long)jr + sizeof(jr->load));
 412         code  = (unsigned long)jr + jr->load.p.total_size - csize;
 413         count = jr->load.code_index;
 414         idr_size = jd->machine->id_hdr_size;
 415
 416         event = calloc(1, sizeof(*event) + idr_size);
 417         if (!event)
 418                 return -1;
 419
 420         filename = event->mmap2.filename;
 421         size = snprintf(filename, PATH_MAX, "%s/jitted-%d-%u.so",
 422                         jd->dir,
 423                         pid,
 424                         count);
 425
 426         size++; /* for \0 */
 427
 428         size = PERF_ALIGN(size, sizeof(u64));
 429         uaddr = (uintptr_t)code;
 430         ret = jit_emit_elf(filename, sym, addr, (const void *)uaddr, csize, jd->debug_data, jd->nr_debug_entries,
 431                            jd->unwinding_data, jd->eh_frame_hdr_size, jd->unwinding_size);
 432
 433         if (jd->debug_data && jd->nr_debug_entries) {
 434                 free(jd->debug_data);
 435                 jd->debug_data = NULL;
 436                 jd->nr_debug_entries = 0;
 437         }
 438
 439         if (jd->unwinding_data && jd->eh_frame_hdr_size) {
 440                 free(jd->unwinding_data);
 441                 jd->unwinding_data = NULL;
 442                 jd->eh_frame_hdr_size = 0;
 443                 jd->unwinding_mapped_size = 0;
 444                 jd->unwinding_size = 0;
 445         }
 446
 447         if (ret) {
 448                 free(event);
 449                 return -1;
 450         }
 451         if (stat(filename, &st))
 452                 memset(&st, 0, sizeof(st));
 453
 454         event->mmap2.header.type = PERF_RECORD_MMAP2;
 455         event->mmap2.header.misc = PERF_RECORD_MISC_USER;
 456         event->mmap2.header.size = (sizeof(event->mmap2) -
 457                         (sizeof(event->mmap2.filename) - size) + idr_size);
 458
 459         event->mmap2.pgoff = GEN_ELF_TEXT_OFFSET;
 460         event->mmap2.start = addr;
 461         event->mmap2.len   = usize ? ALIGN_8(csize) + usize : csize;
 462         event->mmap2.pid   = pid;
 463         event->mmap2.tid   = tid;
 464         event->mmap2.ino   = st.st_ino;
 465         event->mmap2.maj   = major(st.st_dev);
 466         event->mmap2.min   = minor(st.st_dev);
 467         event->mmap2.prot  = st.st_mode;
 468         event->mmap2.flags = MAP_SHARED;
 469         event->mmap2.ino_generation = 1;
 470
 471         id = (void *)((unsigned long)event + event->mmap.header.size - idr_size);
 472         if (jd->sample_type & PERF_SAMPLE_TID) {
 473                 id->pid  = pid;
 474                 id->tid  = tid;
 475         }
 476         if (jd->sample_type & PERF_SAMPLE_TIME)
 477                 id->time = convert_timestamp(jd, jr->load.p.timestamp);
 478
 479         /*
 480          * create pseudo sample to induce dso hit increment
 481          * use first address as sample address
 482          */
 483         memset(&sample, 0, sizeof(sample));
 484         sample.cpumode = PERF_RECORD_MISC_USER;
 485         sample.pid  = pid;
 486         sample.tid  = tid;
 487         sample.time = id->time;
 488         sample.ip   = addr;
 489
 490         ret = perf_event__process_mmap2(tool, event, &sample, jd->machine);
 491         if (ret)
 492                 return ret;
 493
 494         ret = jit_inject_event(jd, event);
 495         /*
 496          * mark dso as use to generate buildid in the header
 497          */
 498         if (!ret)
 499                 build_id__mark_dso_hit(tool, event, &sample, NULL, jd->machine);
 500
 501         return ret;
 502 }
 503
 504 static int jit_repipe_code_move(struct jit_buf_desc *jd, union jr_entry *jr)
 505 {
 506         struct perf_sample sample;
 507         union perf_event *event;
 508         struct perf_tool *tool = jd->session->tool;
 509         char *filename;
 510         size_t size;
 511         struct stat st;
 512         int usize;
 513         u16 idr_size;
 514         int ret;
 515         pid_t pid, tid;
 516         struct {
 517                 u32 pid, tid;
 518                 u64 time;
 519         } *id;
 520
 521         pid = jr->move.pid;
 522         tid =  jr->move.tid;
 523         usize = jd->unwinding_mapped_size;
 524         idr_size = jd->machine->id_hdr_size;
 525
 526         /*
 527          * +16 to account for sample_id_all (hack)
 528          */
 529         event = calloc(1, sizeof(*event) + 16);
 530         if (!event)
 531                 return -1;
 532
 533         filename = event->mmap2.filename;
 534         size = snprintf(filename, PATH_MAX, "%s/jitted-%d-%"PRIu64,
 535                  jd->dir,
 536                  pid,
 537                  jr->move.code_index);
 538
 539         size++; /* for \0 */
 540
 541         if (stat(filename, &st))
 542                 memset(&st, 0, sizeof(st));
 543
 544         size = PERF_ALIGN(size, sizeof(u64));
 545
 546         event->mmap2.header.type = PERF_RECORD_MMAP2;
 547         event->mmap2.header.misc = PERF_RECORD_MISC_USER;
 548         event->mmap2.header.size = (sizeof(event->mmap2) -
 549                         (sizeof(event->mmap2.filename) - size) + idr_size);
 550         event->mmap2.pgoff = GEN_ELF_TEXT_OFFSET;
 551         event->mmap2.start = jr->move.new_code_addr;
 552         event->mmap2.len   = usize ? ALIGN_8(jr->move.code_size) + usize
 553                                    : jr->move.code_size;
 554         event->mmap2.pid   = pid;
 555         event->mmap2.tid   = tid;
 556         event->mmap2.ino   = st.st_ino;
 557         event->mmap2.maj   = major(st.st_dev);
 558         event->mmap2.min   = minor(st.st_dev);
 559         event->mmap2.prot  = st.st_mode;
 560         event->mmap2.flags = MAP_SHARED;
 561         event->mmap2.ino_generation = 1;
 562
 563         id = (void *)((unsigned long)event + event->mmap.header.size - idr_size);
 564         if (jd->sample_type & PERF_SAMPLE_TID) {
 565                 id->pid  = pid;
 566                 id->tid  = tid;
 567         }
 568         if (jd->sample_type & PERF_SAMPLE_TIME)
 569                 id->time = convert_timestamp(jd, jr->load.p.timestamp);
 570
 571         /*
 572          * create pseudo sample to induce dso hit increment
 573          * use first address as sample address
 574          */
 575         memset(&sample, 0, sizeof(sample));
 576         sample.cpumode = PERF_RECORD_MISC_USER;
 577         sample.pid  = pid;
 578         sample.tid  = tid;
 579         sample.time = id->time;
 580         sample.ip   = jr->move.new_code_addr;
 581
 582         ret = perf_event__process_mmap2(tool, event, &sample, jd->machine);
 583         if (ret)
 584                 return ret;
 585
 586         ret = jit_inject_event(jd, event);
 587         if (!ret)
 588                 build_id__mark_dso_hit(tool, event, &sample, NULL, jd->machine);
 589
 590         return ret;
 591 }
 592
 593 static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)
 594 {
 595         void *data;
 596         size_t sz;
 597
 598         if (!(jd && jr))
 599                 return -1;
 600
 601         sz  = jr->prefix.total_size - sizeof(jr->info);
 602         data = malloc(sz);
 603         if (!data)
 604                 return -1;
 605
 606         memcpy(data, &jr->info.entries, sz);
 607
 608         jd->debug_data       = data;
 609
 610         /*
 611          * we must use nr_entry instead of size here because
 612          * we cannot distinguish actual entry from padding otherwise
 613          */
 614         jd->nr_debug_entries = jr->info.nr_entry;
 615
 616         return 0;
 617 }
 618
 619 static int
 620 jit_repipe_unwinding_info(struct jit_buf_desc *jd, union jr_entry *jr)
 621 {
 622         void *unwinding_data;
 623         uint32_t unwinding_data_size;
 624
 625         if (!(jd && jr))
 626                 return -1;
 627
 628         unwinding_data_size  = jr->prefix.total_size - sizeof(jr->unwinding);
 629         unwinding_data = malloc(unwinding_data_size);
 630         if (!unwinding_data)
 631                 return -1;
 632
 633         memcpy(unwinding_data, &jr->unwinding.unwinding_data,
 634                unwinding_data_size);
 635
 636         jd->eh_frame_hdr_size = jr->unwinding.eh_frame_hdr_size;
 637         jd->unwinding_size = jr->unwinding.unwinding_size;
 638         jd->unwinding_mapped_size = jr->unwinding.mapped_size;
 639         jd->unwinding_data = unwinding_data;
 640
 641         return 0;
 642 }
 643
 644 static int
 645 jit_process_dump(struct jit_buf_desc *jd)
 646 {
 647         union jr_entry *jr;
 648         int ret = 0;
 649
 650         while ((jr = jit_get_next_entry(jd))) {
 651                 switch(jr->prefix.id) {
 652                 case JIT_CODE_LOAD:
 653                         ret = jit_repipe_code_load(jd, jr);
 654                         break;
 655                 case JIT_CODE_MOVE:
 656                         ret = jit_repipe_code_move(jd, jr);
 657                         break;
 658                 case JIT_CODE_DEBUG_INFO:
 659                         ret = jit_repipe_debug_info(jd, jr);
 660                         break;
 661                 case JIT_CODE_UNWINDING_INFO:
 662                         ret = jit_repipe_unwinding_info(jd, jr);
 663                         break;
 664                 default:
 665                         ret = 0;
 666                         continue;
 667                 }
 668         }
 669         return ret;
 670 }
 671
 672 static int
 673 jit_inject(struct jit_buf_desc *jd, char *path)
 674 {
 675         int ret;
 676
 677         if (verbose > 0)
 678                 fprintf(stderr, "injecting: %s\n", path);
 679
 680         ret = jit_open(jd, path);
 681         if (ret)
 682                 return -1;
 683
 684         ret = jit_process_dump(jd);
 685
 686         jit_close(jd);
 687
 688         if (verbose > 0)
 689                 fprintf(stderr, "injected: %s (%d)\n", path, ret);
 690
 691         return 0;
 692 }
 693
 694 /*
 695  * File must be with pattern .../jit-XXXX.dump
 696  * where XXXX is the PID of the process which did the mmap()
 697  * as captured in the RECORD_MMAP record
 698  */
 699 static int
 700 jit_detect(char *mmap_name, pid_t pid)
 701  {
 702         char *p;
 703         char *end = NULL;
 704         pid_t pid2;
 705
 706         if (verbose > 2)
 707                 fprintf(stderr, "jit marker trying : %s\n", mmap_name);
 708         /*
 709          * get file name
 710          */
 711         p = strrchr(mmap_name, '/');
 712         if (!p)
 713                 return -1;
 714
 715         /*
 716          * match prefix
 717          */
 718         if (strncmp(p, "/jit-", 5))
 719                 return -1;
 720
 721         /*
 722          * skip prefix
 723          */
 724         p += 5;
 725
 726         /*
 727          * must be followed by a pid
 728          */
 729         if (!isdigit(*p))
 730                 return -1;
 731
 732         pid2 = (int)strtol(p, &end, 10);
 733         if (!end)
 734                 return -1;
 735
 736         /*
 737          * pid does not match mmap pid
 738          * pid==0 in system-wide mode (synthesized)
 739          */
 740         if (pid && pid2 != pid)
 741                 return -1;
 742         /*
 743          * validate suffix
 744          */
 745         if (strcmp(end, ".dump"))
 746                 return -1;
 747
 748         if (verbose > 0)
 749                 fprintf(stderr, "jit marker found: %s\n", mmap_name);
 750
 751         return 0;
 752 }
 753
 754 int
 755 jit_process(struct perf_session *session,
 756             struct perf_data *output,
 757             struct machine *machine,
 758             char *filename,
 759             pid_t pid,
 760             u64 *nbytes)
 761 {
 762         struct perf_evsel *first;
 763         struct jit_buf_desc jd;
 764         int ret;
 765
 766         /*
 767          * first, detect marker mmap (i.e., the jitdump mmap)
 768          */
 769         if (jit_detect(filename, pid))
 770                 return 0;
 771
 772         memset(&jd, 0, sizeof(jd));
 773
 774         jd.session = session;
 775         jd.output  = output;
 776         jd.machine = machine;
 777
 778         /*
 779          * track sample_type to compute id_all layout
 780          * perf sets the same sample type to all events as of now
 781          */
 782         first = perf_evlist__first(session->evlist);
 783         jd.sample_type = first->attr.sample_type;
 784
 785         *nbytes = 0;
 786
 787         ret = jit_inject(&jd, filename);
 788         if (!ret) {
 789                 *nbytes = jd.bytes_written;
 790                 ret = 1;
 791         }
 792
 793         return ret;
 794 }