|
|
@@ -0,0 +1,465 @@
|
|
|
+/*
|
|
|
+ * jvmti_agent.c: JVMTI agent interface
|
|
|
+ *
|
|
|
+ * Adapted from the Oprofile code in opagent.c:
|
|
|
+ * This library is free software; you can redistribute it and/or
|
|
|
+ * modify it under the terms of the GNU Lesser General Public
|
|
|
+ * License as published by the Free Software Foundation; either
|
|
|
+ * version 2.1 of the License, or (at your option) any later version.
|
|
|
+ *
|
|
|
+ * This library is distributed in the hope that it will be useful,
|
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
+ * Lesser General Public License for more details.
|
|
|
+ *
|
|
|
+ * You should have received a copy of the GNU Lesser General Public
|
|
|
+ * License along with this library; if not, write to the Free Software
|
|
|
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
+ *
|
|
|
+ * Copyright 2007 OProfile authors
|
|
|
+ * Jens Wilke
|
|
|
+ * Daniel Hansel
|
|
|
+ * Copyright IBM Corporation 2007
|
|
|
+ */
|
|
|
+#include <sys/types.h>
|
|
|
+#include <sys/stat.h> /* for mkdir() */
|
|
|
+#include <stdio.h>
|
|
|
+#include <errno.h>
|
|
|
+#include <string.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <stdint.h>
|
|
|
+#include <limits.h>
|
|
|
+#include <fcntl.h>
|
|
|
+#include <unistd.h>
|
|
|
+#include <time.h>
|
|
|
+#include <sys/mman.h>
|
|
|
+#include <syscall.h> /* for gettid() */
|
|
|
+#include <err.h>
|
|
|
+
|
|
|
+#include "jvmti_agent.h"
|
|
|
+#include "../util/jitdump.h"
|
|
|
+
|
|
|
+#define JIT_LANG "java"
|
|
|
+
|
|
|
+static char jit_path[PATH_MAX];
|
|
|
+static void *marker_addr;
|
|
|
+
|
|
|
+/*
|
|
|
+ * padding buffer
|
|
|
+ */
|
|
|
+static const char pad_bytes[7];
|
|
|
+
|
|
|
+static inline pid_t gettid(void)
|
|
|
+{
|
|
|
+ return (pid_t)syscall(__NR_gettid);
|
|
|
+}
|
|
|
+
|
|
|
+static int get_e_machine(struct jitheader *hdr)
|
|
|
+{
|
|
|
+ ssize_t sret;
|
|
|
+ char id[16];
|
|
|
+ int fd, ret = -1;
|
|
|
+ int m = -1;
|
|
|
+ struct {
|
|
|
+ uint16_t e_type;
|
|
|
+ uint16_t e_machine;
|
|
|
+ } info;
|
|
|
+
|
|
|
+ fd = open("/proc/self/exe", O_RDONLY);
|
|
|
+ if (fd == -1)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ sret = read(fd, id, sizeof(id));
|
|
|
+ if (sret != sizeof(id))
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ /* check ELF signature */
|
|
|
+ if (id[0] != 0x7f || id[1] != 'E' || id[2] != 'L' || id[3] != 'F')
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ sret = read(fd, &info, sizeof(info));
|
|
|
+ if (sret != sizeof(info))
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ m = info.e_machine;
|
|
|
+ if (m < 0)
|
|
|
+ m = 0; /* ELF EM_NONE */
|
|
|
+
|
|
|
+ hdr->elf_mach = m;
|
|
|
+ ret = 0;
|
|
|
+error:
|
|
|
+ close(fd);
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+#define NSEC_PER_SEC 1000000000
|
|
|
+static int perf_clk_id = CLOCK_MONOTONIC;
|
|
|
+
|
|
|
+static inline uint64_t
|
|
|
+timespec_to_ns(const struct timespec *ts)
|
|
|
+{
|
|
|
+ return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
|
|
|
+}
|
|
|
+
|
|
|
+static inline uint64_t
|
|
|
+perf_get_timestamp(void)
|
|
|
+{
|
|
|
+ struct timespec ts;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ ret = clock_gettime(perf_clk_id, &ts);
|
|
|
+ if (ret)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ return timespec_to_ns(&ts);
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+debug_cache_init(void)
|
|
|
+{
|
|
|
+ char str[32];
|
|
|
+ char *base, *p;
|
|
|
+ struct tm tm;
|
|
|
+ time_t t;
|
|
|
+ int ret;
|
|
|
+
|
|
|
+ time(&t);
|
|
|
+ localtime_r(&t, &tm);
|
|
|
+
|
|
|
+ base = getenv("JITDUMPDIR");
|
|
|
+ if (!base)
|
|
|
+ base = getenv("HOME");
|
|
|
+ if (!base)
|
|
|
+ base = ".";
|
|
|
+
|
|
|
+ strftime(str, sizeof(str), JIT_LANG"-jit-%Y%m%d", &tm);
|
|
|
+
|
|
|
+ snprintf(jit_path, PATH_MAX - 1, "%s/.debug/", base);
|
|
|
+
|
|
|
+ ret = mkdir(jit_path, 0755);
|
|
|
+ if (ret == -1) {
|
|
|
+ if (errno != EEXIST) {
|
|
|
+ warn("jvmti: cannot create jit cache dir %s", jit_path);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit", base);
|
|
|
+ ret = mkdir(jit_path, 0755);
|
|
|
+ if (ret == -1) {
|
|
|
+ if (errno != EEXIST) {
|
|
|
+ warn("cannot create jit cache dir %s", jit_path);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit/%s.XXXXXXXX", base, str);
|
|
|
+
|
|
|
+ p = mkdtemp(jit_path);
|
|
|
+ if (p != jit_path) {
|
|
|
+ warn("cannot create jit cache dir %s", jit_path);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int
|
|
|
+perf_open_marker_file(int fd)
|
|
|
+{
|
|
|
+ long pgsz;
|
|
|
+
|
|
|
+ pgsz = sysconf(_SC_PAGESIZE);
|
|
|
+ if (pgsz == -1)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * we mmap the jitdump to create an MMAP RECORD in perf.data file.
|
|
|
+ * The mmap is captured either live (perf record running when we mmap)
|
|
|
+ * or in deferred mode, via /proc/PID/maps
|
|
|
+ * the MMAP record is used as a marker of a jitdump file for more meta
|
|
|
+ * data info about the jitted code. Perf report/annotate detect this
|
|
|
+ * special filename and process the jitdump file.
|
|
|
+ *
|
|
|
+ * mapping must be PROT_EXEC to ensure it is captured by perf record
|
|
|
+ * even when not using -d option
|
|
|
+ */
|
|
|
+ marker_addr = mmap(NULL, pgsz, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0);
|
|
|
+ return (marker_addr == MAP_FAILED) ? -1 : 0;
|
|
|
+}
|
|
|
+
|
|
|
+static void
|
|
|
+perf_close_marker_file(void)
|
|
|
+{
|
|
|
+ long pgsz;
|
|
|
+
|
|
|
+ if (!marker_addr)
|
|
|
+ return;
|
|
|
+
|
|
|
+ pgsz = sysconf(_SC_PAGESIZE);
|
|
|
+ if (pgsz == -1)
|
|
|
+ return;
|
|
|
+
|
|
|
+ munmap(marker_addr, pgsz);
|
|
|
+}
|
|
|
+
|
|
|
+void *jvmti_open(void)
|
|
|
+{
|
|
|
+ int pad_cnt;
|
|
|
+ char dump_path[PATH_MAX];
|
|
|
+ struct jitheader header;
|
|
|
+ int fd;
|
|
|
+ FILE *fp;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * check if clockid is supported
|
|
|
+ */
|
|
|
+ if (!perf_get_timestamp())
|
|
|
+ warnx("jvmti: kernel does not support %d clock id", perf_clk_id);
|
|
|
+
|
|
|
+ memset(&header, 0, sizeof(header));
|
|
|
+
|
|
|
+ debug_cache_init();
|
|
|
+
|
|
|
+ /*
|
|
|
+ * jitdump file name
|
|
|
+ */
|
|
|
+ snprintf(dump_path, PATH_MAX, "%s/jit-%i.dump", jit_path, getpid());
|
|
|
+
|
|
|
+ fd = open(dump_path, O_CREAT|O_TRUNC|O_RDWR, 0666);
|
|
|
+ if (fd == -1)
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * create perf.data maker for the jitdump file
|
|
|
+ */
|
|
|
+ if (perf_open_marker_file(fd)) {
|
|
|
+ warnx("jvmti: failed to create marker file");
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ fp = fdopen(fd, "w+");
|
|
|
+ if (!fp) {
|
|
|
+ warn("jvmti: cannot create %s", dump_path);
|
|
|
+ close(fd);
|
|
|
+ goto error;
|
|
|
+ }
|
|
|
+
|
|
|
+ warnx("jvmti: jitdump in %s", dump_path);
|
|
|
+
|
|
|
+ if (get_e_machine(&header)) {
|
|
|
+ warn("get_e_machine failed\n");
|
|
|
+ goto error;
|
|
|
+ }
|
|
|
+
|
|
|
+ header.magic = JITHEADER_MAGIC;
|
|
|
+ header.version = JITHEADER_VERSION;
|
|
|
+ header.total_size = sizeof(header);
|
|
|
+ header.pid = getpid();
|
|
|
+
|
|
|
+ /* calculate amount of padding '\0' */
|
|
|
+ pad_cnt = PADDING_8ALIGNED(header.total_size);
|
|
|
+ header.total_size += pad_cnt;
|
|
|
+
|
|
|
+ header.timestamp = perf_get_timestamp();
|
|
|
+
|
|
|
+ if (!fwrite(&header, sizeof(header), 1, fp)) {
|
|
|
+ warn("jvmti: cannot write dumpfile header");
|
|
|
+ goto error;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* write padding '\0' if necessary */
|
|
|
+ if (pad_cnt && !fwrite(pad_bytes, pad_cnt, 1, fp)) {
|
|
|
+ warn("jvmti: cannot write dumpfile header padding");
|
|
|
+ goto error;
|
|
|
+ }
|
|
|
+
|
|
|
+ return fp;
|
|
|
+error:
|
|
|
+ fclose(fp);
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+jvmti_close(void *agent)
|
|
|
+{
|
|
|
+ struct jr_code_close rec;
|
|
|
+ FILE *fp = agent;
|
|
|
+
|
|
|
+ if (!fp) {
|
|
|
+ warnx("jvmti: incalid fd in close_agent");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ rec.p.id = JIT_CODE_CLOSE;
|
|
|
+ rec.p.total_size = sizeof(rec);
|
|
|
+
|
|
|
+ rec.p.timestamp = perf_get_timestamp();
|
|
|
+
|
|
|
+ if (!fwrite(&rec, sizeof(rec), 1, fp))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ fclose(fp);
|
|
|
+
|
|
|
+ fp = NULL;
|
|
|
+
|
|
|
+ perf_close_marker_file();
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+jvmti_write_code(void *agent, char const *sym,
|
|
|
+ uint64_t vma, void const *code, unsigned int const size)
|
|
|
+{
|
|
|
+ static int code_generation = 1;
|
|
|
+ struct jr_code_load rec;
|
|
|
+ size_t sym_len;
|
|
|
+ size_t padding_count;
|
|
|
+ FILE *fp = agent;
|
|
|
+ int ret = -1;
|
|
|
+
|
|
|
+ /* don't care about 0 length function, no samples */
|
|
|
+ if (size == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ if (!fp) {
|
|
|
+ warnx("jvmti: invalid fd in write_native_code");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ sym_len = strlen(sym) + 1;
|
|
|
+
|
|
|
+ rec.p.id = JIT_CODE_LOAD;
|
|
|
+ rec.p.total_size = sizeof(rec) + sym_len;
|
|
|
+ padding_count = PADDING_8ALIGNED(rec.p.total_size);
|
|
|
+ rec.p. total_size += padding_count;
|
|
|
+ rec.p.timestamp = perf_get_timestamp();
|
|
|
+
|
|
|
+ rec.code_size = size;
|
|
|
+ rec.vma = vma;
|
|
|
+ rec.code_addr = vma;
|
|
|
+ rec.pid = getpid();
|
|
|
+ rec.tid = gettid();
|
|
|
+
|
|
|
+ if (code)
|
|
|
+ rec.p.total_size += size;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * If JVM is multi-threaded, nultiple concurrent calls to agent
|
|
|
+ * may be possible, so protect file writes
|
|
|
+ */
|
|
|
+ flockfile(fp);
|
|
|
+
|
|
|
+ /*
|
|
|
+ * get code index inside lock to avoid race condition
|
|
|
+ */
|
|
|
+ rec.code_index = code_generation++;
|
|
|
+
|
|
|
+ ret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);
|
|
|
+ fwrite_unlocked(sym, sym_len, 1, fp);
|
|
|
+
|
|
|
+ if (padding_count)
|
|
|
+ fwrite_unlocked(pad_bytes, padding_count, 1, fp);
|
|
|
+
|
|
|
+ if (code)
|
|
|
+ fwrite_unlocked(code, size, 1, fp);
|
|
|
+
|
|
|
+ funlockfile(fp);
|
|
|
+
|
|
|
+ ret = 0;
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+int
|
|
|
+jvmti_write_debug_info(void *agent, uint64_t code, const char *file,
|
|
|
+ jvmtiAddrLocationMap const *map,
|
|
|
+ jvmtiLineNumberEntry *li, jint num)
|
|
|
+{
|
|
|
+ static const char *prev_str = "\xff";
|
|
|
+ struct jr_code_debug_info rec;
|
|
|
+ size_t sret, len, size, flen;
|
|
|
+ size_t padding_count;
|
|
|
+ FILE *fp = agent;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * no entry to write
|
|
|
+ */
|
|
|
+ if (!num)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ if (!fp) {
|
|
|
+ warnx("jvmti: invalid fd in write_debug_info");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ flen = strlen(file) + 1;
|
|
|
+
|
|
|
+ rec.p.id = JIT_CODE_DEBUG_INFO;
|
|
|
+ size = sizeof(rec);
|
|
|
+ rec.p.timestamp = perf_get_timestamp();
|
|
|
+ rec.code_addr = (uint64_t)(uintptr_t)code;
|
|
|
+ rec.nr_entry = num;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * on disk source line info layout:
|
|
|
+ * uint64_t : addr
|
|
|
+ * int : line number
|
|
|
+ * file[] : source file name
|
|
|
+ * padding : pad to multiple of 8 bytes
|
|
|
+ */
|
|
|
+ size += num * (sizeof(uint64_t) + sizeof(int));
|
|
|
+ size += flen + (num - 1) * 2;
|
|
|
+ /*
|
|
|
+ * pad to 8 bytes
|
|
|
+ */
|
|
|
+ padding_count = PADDING_8ALIGNED(size);
|
|
|
+
|
|
|
+ rec.p.total_size = size + padding_count;
|
|
|
+
|
|
|
+ /*
|
|
|
+ * If JVM is multi-threaded, nultiple concurrent calls to agent
|
|
|
+ * may be possible, so protect file writes
|
|
|
+ */
|
|
|
+ flockfile(fp);
|
|
|
+
|
|
|
+ sret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);
|
|
|
+ if (sret != 1)
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ for (i = 0; i < num; i++) {
|
|
|
+ uint64_t addr;
|
|
|
+
|
|
|
+ addr = (uint64_t)map[i].start_address;
|
|
|
+ len = sizeof(addr);
|
|
|
+ sret = fwrite_unlocked(&addr, len, 1, fp);
|
|
|
+ if (sret != 1)
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ len = sizeof(int);
|
|
|
+ sret = fwrite_unlocked(&li[i].line_number, len, 1, fp);
|
|
|
+ if (sret != 1)
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ if (i == 0) {
|
|
|
+ sret = fwrite_unlocked(file, flen, 1, fp);
|
|
|
+ } else {
|
|
|
+ sret = fwrite_unlocked(prev_str, 2, 1, fp);
|
|
|
+ }
|
|
|
+ if (sret != 1)
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ }
|
|
|
+ if (padding_count)
|
|
|
+ sret = fwrite_unlocked(pad_bytes, padding_count, 1, fp);
|
|
|
+ if (sret != 1)
|
|
|
+ goto error;
|
|
|
+
|
|
|
+ funlockfile(fp);
|
|
|
+ return 0;
|
|
|
+error:
|
|
|
+ funlockfile(fp);
|
|
|
+ return -1;
|
|
|
+}
|
Stephane Eranian