| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #include <stdio.h> |
| #include <unistd.h> |
| #include <time.h> |
| #include <sys/mman.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <string.h> |
| # include <limits.h> |
|
|
| #if defined(__linux__) |
| #include <sys/syscall.h> |
| #elif defined(__darwin__) |
| # include <pthread.h> |
| #elif defined(__FreeBSD__) |
| # include <sys/thr.h> |
| # include <sys/sysctl.h> |
| #elif defined(__NetBSD__) |
| # include <lwp.h> |
| #elif defined(__DragonFly__) |
| # include <sys/lwp.h> |
| # include <sys/sysctl.h> |
| #elif defined(__sun) |
| |
| extern unsigned int thr_self(void); |
| #elif defined(__HAIKU__) |
| #include <FindDirectory.h> |
| #endif |
|
|
| #include "ir.h" |
| #include "ir_elf.h" |
|
|
| #define IR_PERF_JITDUMP_HEADER_MAGIC 0x4A695444 |
| #define IR_PERF_JITDUMP_HEADER_VERSION 1 |
|
|
| #define IR_PERF_JITDUMP_RECORD_LOAD 0 |
| #define IR_PERF_JITDUMP_RECORD_MOVE 1 |
| #define IR_PERF_JITDUMP_RECORD_DEBUG_INFO 2 |
| #define IR_PERF_JITDUMP_RECORD_CLOSE 3 |
| #define IR_PERF_JITDUMP_UNWINDING_UNFO 4 |
|
|
| #define ALIGN8(size) (((size) + 7) & ~7) |
| #define PADDING8(size) (ALIGN8(size) - (size)) |
|
|
| typedef struct ir_perf_jitdump_header { |
| uint32_t magic; |
| uint32_t version; |
| uint32_t size; |
| uint32_t elf_mach_target; |
| uint32_t reserved; |
| uint32_t process_id; |
| uint64_t time_stamp; |
| uint64_t flags; |
| } ir_perf_jitdump_header; |
|
|
| typedef struct _ir_perf_jitdump_record { |
| uint32_t event; |
| uint32_t size; |
| uint64_t time_stamp; |
| } ir_perf_jitdump_record; |
|
|
| typedef struct _ir_perf_jitdump_load_record { |
| ir_perf_jitdump_record hdr; |
| uint32_t process_id; |
| uint32_t thread_id; |
| uint64_t vma; |
| uint64_t code_address; |
| uint64_t code_size; |
| uint64_t code_id; |
| } ir_perf_jitdump_load_record; |
|
|
| static int jitdump_fd = -1; |
| static void *jitdump_mem = MAP_FAILED; |
|
|
| static uint64_t ir_perf_timestamp(void) |
| { |
| struct timespec ts; |
|
|
| if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) { |
| return 0; |
| } |
| return ((uint64_t)ts.tv_sec * 1000000000) + ts.tv_nsec; |
| } |
|
|
| int ir_perf_jitdump_open(void) |
| { |
| char filename[64]; |
| int fd, ret; |
| ir_elf_header elf_hdr; |
| ir_perf_jitdump_header jit_hdr; |
|
|
| snprintf(filename, sizeof(filename), "/tmp/jit-%d.dump", getpid()); |
| if (!ir_perf_timestamp()) { |
| return 0; |
| } |
|
|
| #if defined(__linux__) |
| fd = open("/proc/self/exe", O_RDONLY); |
| #elif defined(__NetBSD__) |
| fd = open("/proc/curproc/exe", O_RDONLY); |
| #elif defined(__FreeBSD__) || defined(__DragonFly__) |
| char path[PATH_MAX]; |
| size_t pathlen = sizeof(path); |
| int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1}; |
| if (sysctl(mib, 4, path, &pathlen, NULL, 0) == -1) { |
| return 0; |
| } |
| fd = open(path, O_RDONLY); |
| #elif defined(__sun) |
| fd = open("/proc/self/path/a.out", O_RDONLY); |
| #elif defined(__HAIKU__) |
| char path[PATH_MAX]; |
| if (find_path(B_APP_IMAGE_SYMBOL, B_FIND_PATH_IMAGE_PATH, |
| NULL, path, sizeof(path)) != B_OK) { |
| return 0; |
| } |
|
|
| fd = open(path, O_RDONLY); |
| #else |
| fd = -1; |
| #endif |
| if (fd < 0) { |
| return 0; |
| } |
|
|
| ret = read(fd, &elf_hdr, sizeof(elf_hdr)); |
| close(fd); |
|
|
| if (ret != sizeof(elf_hdr) || |
| elf_hdr.emagic[0] != 0x7f || |
| elf_hdr.emagic[1] != 'E' || |
| elf_hdr.emagic[2] != 'L' || |
| elf_hdr.emagic[3] != 'F') { |
| return 0; |
| } |
|
|
| jitdump_fd = open(filename, O_CREAT | O_TRUNC | O_RDWR, 0666); |
| if (jitdump_fd < 0) { |
| return 0; |
| } |
|
|
| jitdump_mem = mmap(NULL, |
| sysconf(_SC_PAGESIZE), |
| PROT_READ|PROT_EXEC, |
| MAP_PRIVATE, jitdump_fd, 0); |
|
|
| if (jitdump_mem == MAP_FAILED) { |
| close(jitdump_fd); |
| jitdump_fd = -1; |
| return 0; |
| } |
|
|
| memset(&jit_hdr, 0, sizeof(jit_hdr)); |
| jit_hdr.magic = IR_PERF_JITDUMP_HEADER_MAGIC; |
| jit_hdr.version = IR_PERF_JITDUMP_HEADER_VERSION; |
| jit_hdr.size = sizeof(jit_hdr); |
| jit_hdr.elf_mach_target = elf_hdr.machine; |
| jit_hdr.process_id = getpid(); |
| jit_hdr.time_stamp = ir_perf_timestamp(); |
| jit_hdr.flags = 0; |
| if (write(jitdump_fd, &jit_hdr, sizeof(jit_hdr)) != sizeof(jit_hdr)) { |
| return 0; |
| } |
| return 1; |
| } |
|
|
| int ir_perf_jitdump_close(void) |
| { |
| int ret = 1; |
|
|
| if (jitdump_fd >= 0) { |
| ir_perf_jitdump_record rec; |
|
|
| rec.event = IR_PERF_JITDUMP_RECORD_CLOSE; |
| rec.size = sizeof(rec); |
| rec.time_stamp = ir_perf_timestamp(); |
| if (write(jitdump_fd, &rec, sizeof(rec)) != sizeof(rec)) { |
| ret = 0; |
| } |
| close(jitdump_fd); |
|
|
| if (jitdump_mem != MAP_FAILED) { |
| munmap(jitdump_mem, sysconf(_SC_PAGESIZE)); |
| } |
| } |
| return ret; |
| } |
|
|
| int ir_perf_jitdump_register(const char *name, const void *start, size_t size) |
| { |
| if (jitdump_fd >= 0) { |
| static uint64_t id = 1; |
| ir_perf_jitdump_load_record rec; |
| size_t len = strlen(name); |
| uint32_t thread_id = 0; |
| #if defined(__linux__) |
| thread_id = syscall(SYS_gettid); |
| #elif defined(__darwin__) |
| uint64_t thread_id_u64; |
| pthread_threadid_np(NULL, &thread_id_u64); |
| thread_id = (uint32_t) thread_id_u64; |
| #elif defined(__FreeBSD__) |
| long tid; |
| thr_self(&tid); |
| thread_id = (uint32_t)tid; |
| #elif defined(__OpenBSD__) |
| thread_id = getthrid(); |
| #elif defined(__NetBSD__) |
| thread_id = _lwp_self(); |
| #elif defined(__DragonFly__) |
| thread_id = lwp_gettid(); |
| #elif defined(__sun) |
| thread_id = thr_self(); |
| #endif |
|
|
| memset(&rec, 0, sizeof(rec)); |
| rec.hdr.event = IR_PERF_JITDUMP_RECORD_LOAD; |
| rec.hdr.size = sizeof(rec) + len + 1 + size; |
| rec.hdr.time_stamp = ir_perf_timestamp(); |
| rec.process_id = getpid(); |
| rec.thread_id = thread_id; |
| rec.vma = (uint64_t)(uintptr_t)start; |
| rec.code_address = (uint64_t)(uintptr_t)start; |
| rec.code_size = (uint64_t)size; |
| rec.code_id = id++; |
|
|
| if (write(jitdump_fd, &rec, sizeof(rec)) != sizeof(rec) |
| || write(jitdump_fd, name, len + 1) < 0 |
| || write(jitdump_fd, start, size) < 0) { |
| return 0; |
| } |
| } |
| return 1; |
| } |
|
|
| void ir_perf_map_register(const char *name, const void *start, size_t size) |
| { |
| static FILE *fp = NULL; |
|
|
| if (!fp) { |
| char filename[64]; |
|
|
| snprintf(filename, sizeof(filename), "/tmp/perf-%d.map", getpid()); |
| fp = fopen(filename, "w"); |
| if (!fp) { |
| return; |
| } |
| setlinebuf(fp); |
| } |
| fprintf(fp, "%zx %zx %s\n", (size_t)(uintptr_t)start, size, name); |
| } |
|
|
