2 * jvmti_agent.c: JVMTI agent interface
4 * Adapted from the Oprofile code in opagent.c:
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * Copyright 2007 OProfile authors
22 * Copyright IBM Corporation 2007
24 #include <sys/types.h>
25 #include <sys/stat.h> /* for mkdir() */
36 #include <syscall.h> /* for gettid() */
39 #include "jvmti_agent.h"
40 #include "../util/jitdump.h"
42 #define JIT_LANG "java"
44 static char jit_path[PATH_MAX];
45 static void *marker_addr;
50 static const char pad_bytes[7];
52 static inline pid_t gettid(void)
54 return (pid_t)syscall(__NR_gettid);
57 static int get_e_machine(struct jitheader *hdr)
68 fd = open("/proc/self/exe", O_RDONLY);
72 sret = read(fd, id, sizeof(id));
73 if (sret != sizeof(id))
76 /* check ELF signature */
77 if (id[0] != 0x7f || id[1] != 'E' || id[2] != 'L' || id[3] != 'F')
80 sret = read(fd, &info, sizeof(info));
81 if (sret != sizeof(info))
86 m = 0; /* ELF EM_NONE */
95 static int use_arch_timestamp;
97 static inline uint64_t
98 get_arch_timestamp(void)
100 #if defined(__i386__) || defined(__x86_64__)
101 unsigned int low, high;
103 asm volatile("rdtsc" : "=a" (low), "=d" (high));
105 return low | ((uint64_t)high) << 32;
111 #define NSEC_PER_SEC 1000000000
112 static int perf_clk_id = CLOCK_MONOTONIC;
114 static inline uint64_t
115 timespec_to_ns(const struct timespec *ts)
117 return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
120 static inline uint64_t
121 perf_get_timestamp(void)
126 if (use_arch_timestamp)
127 return get_arch_timestamp();
129 ret = clock_gettime(perf_clk_id, &ts);
133 return timespec_to_ns(&ts);
137 debug_cache_init(void)
146 localtime_r(&t, &tm);
148 base = getenv("JITDUMPDIR");
150 base = getenv("HOME");
154 strftime(str, sizeof(str), JIT_LANG"-jit-%Y%m%d", &tm);
156 snprintf(jit_path, PATH_MAX - 1, "%s/.debug/", base);
158 ret = mkdir(jit_path, 0755);
160 if (errno != EEXIST) {
161 warn("jvmti: cannot create jit cache dir %s", jit_path);
166 snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit", base);
167 ret = mkdir(jit_path, 0755);
169 if (errno != EEXIST) {
170 warn("cannot create jit cache dir %s", jit_path);
175 snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit/%s.XXXXXXXX", base, str);
177 p = mkdtemp(jit_path);
179 warn("cannot create jit cache dir %s", jit_path);
187 perf_open_marker_file(int fd)
191 pgsz = sysconf(_SC_PAGESIZE);
196 * we mmap the jitdump to create an MMAP RECORD in perf.data file.
197 * The mmap is captured either live (perf record running when we mmap)
198 * or in deferred mode, via /proc/PID/maps
199 * the MMAP record is used as a marker of a jitdump file for more meta
200 * data info about the jitted code. Perf report/annotate detect this
201 * special filename and process the jitdump file.
203 * mapping must be PROT_EXEC to ensure it is captured by perf record
204 * even when not using -d option
206 marker_addr = mmap(NULL, pgsz, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0);
207 return (marker_addr == MAP_FAILED) ? -1 : 0;
211 perf_close_marker_file(void)
218 pgsz = sysconf(_SC_PAGESIZE);
222 munmap(marker_addr, pgsz);
226 init_arch_timestamp(void)
228 char *str = getenv("JITDUMP_USE_ARCH_TIMESTAMP");
230 if (!str || !*str || !strcmp(str, "0"))
233 use_arch_timestamp = 1;
236 void *jvmti_open(void)
239 char dump_path[PATH_MAX];
240 struct jitheader header;
244 init_arch_timestamp();
247 * check if clockid is supported
249 if (!perf_get_timestamp()) {
250 if (use_arch_timestamp)
251 warnx("jvmti: arch timestamp not supported");
253 warnx("jvmti: kernel does not support %d clock id", perf_clk_id);
256 memset(&header, 0, sizeof(header));
263 snprintf(dump_path, PATH_MAX, "%s/jit-%i.dump", jit_path, getpid());
265 fd = open(dump_path, O_CREAT|O_TRUNC|O_RDWR, 0666);
270 * create perf.data maker for the jitdump file
272 if (perf_open_marker_file(fd)) {
273 warnx("jvmti: failed to create marker file");
277 fp = fdopen(fd, "w+");
279 warn("jvmti: cannot create %s", dump_path);
284 warnx("jvmti: jitdump in %s", dump_path);
286 if (get_e_machine(&header)) {
287 warn("get_e_machine failed\n");
291 header.magic = JITHEADER_MAGIC;
292 header.version = JITHEADER_VERSION;
293 header.total_size = sizeof(header);
294 header.pid = getpid();
296 /* calculate amount of padding '\0' */
297 pad_cnt = PADDING_8ALIGNED(header.total_size);
298 header.total_size += pad_cnt;
300 header.timestamp = perf_get_timestamp();
302 if (use_arch_timestamp)
303 header.flags |= JITDUMP_FLAGS_ARCH_TIMESTAMP;
305 if (!fwrite(&header, sizeof(header), 1, fp)) {
306 warn("jvmti: cannot write dumpfile header");
310 /* write padding '\0' if necessary */
311 if (pad_cnt && !fwrite(pad_bytes, pad_cnt, 1, fp)) {
312 warn("jvmti: cannot write dumpfile header padding");
323 jvmti_close(void *agent)
325 struct jr_code_close rec;
329 warnx("jvmti: incalid fd in close_agent");
333 rec.p.id = JIT_CODE_CLOSE;
334 rec.p.total_size = sizeof(rec);
336 rec.p.timestamp = perf_get_timestamp();
338 if (!fwrite(&rec, sizeof(rec), 1, fp))
345 perf_close_marker_file();
351 jvmti_write_code(void *agent, char const *sym,
352 uint64_t vma, void const *code, unsigned int const size)
354 static int code_generation = 1;
355 struct jr_code_load rec;
357 size_t padding_count;
361 /* don't care about 0 length function, no samples */
366 warnx("jvmti: invalid fd in write_native_code");
370 sym_len = strlen(sym) + 1;
372 rec.p.id = JIT_CODE_LOAD;
373 rec.p.total_size = sizeof(rec) + sym_len;
374 padding_count = PADDING_8ALIGNED(rec.p.total_size);
375 rec.p. total_size += padding_count;
376 rec.p.timestamp = perf_get_timestamp();
378 rec.code_size = size;
385 rec.p.total_size += size;
388 * If JVM is multi-threaded, nultiple concurrent calls to agent
389 * may be possible, so protect file writes
394 * get code index inside lock to avoid race condition
396 rec.code_index = code_generation++;
398 ret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);
399 fwrite_unlocked(sym, sym_len, 1, fp);
402 fwrite_unlocked(pad_bytes, padding_count, 1, fp);
405 fwrite_unlocked(code, size, 1, fp);
415 jvmti_write_debug_info(void *agent, uint64_t code, const char *file,
416 jvmti_line_info_t *li, int nr_lines)
418 struct jr_code_debug_info rec;
419 size_t sret, len, size, flen;
420 size_t padding_count;
422 const char *fn = file;
433 warnx("jvmti: invalid fd in write_debug_info");
437 flen = strlen(file) + 1;
439 rec.p.id = JIT_CODE_DEBUG_INFO;
441 rec.p.timestamp = perf_get_timestamp();
442 rec.code_addr = (uint64_t)(uintptr_t)code;
443 rec.nr_entry = nr_lines;
446 * on disk source line info layout:
449 * int : column discriminator
450 * file[] : source file name
451 * padding : pad to multiple of 8 bytes
453 size += nr_lines * sizeof(struct debug_entry);
454 size += flen * nr_lines;
458 padding_count = PADDING_8ALIGNED(size);
460 rec.p.total_size = size + padding_count;
463 * If JVM is multi-threaded, nultiple concurrent calls to agent
464 * may be possible, so protect file writes
468 sret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);
472 for (i = 0; i < nr_lines; i++) {
474 addr = (uint64_t)li[i].pc;
476 sret = fwrite_unlocked(&addr, len, 1, fp);
480 len = sizeof(li[0].line_number);
481 sret = fwrite_unlocked(&li[i].line_number, len, 1, fp);
485 len = sizeof(li[0].discrim);
486 sret = fwrite_unlocked(&li[i].discrim, len, 1, fp);
490 sret = fwrite_unlocked(fn, flen, 1, fp);
495 sret = fwrite_unlocked(pad_bytes, padding_count, 1, fp);