1 /* 2 * jvmti_agent.c: JVMTI agent interface 3 * 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. 9 * 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. 14 * 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 18 * 19 * Copyright 2007 OProfile authors 20 * Jens Wilke 21 * Daniel Hansel 22 * Copyright IBM Corporation 2007 23 */ 24 #include <sys/types.h> 25 #include <sys/stat.h> /* for mkdir() */ 26 #include <stdio.h> 27 #include <errno.h> 28 #include <string.h> 29 #include <stdlib.h> 30 #include <stdint.h> 31 #include <limits.h> 32 #include <fcntl.h> 33 #include <unistd.h> 34 #include <time.h> 35 #include <sys/mman.h> 36 #include <syscall.h> /* for gettid() */ 37 #include <err.h> 38 #include <linux/kernel.h> 39 40 #include "jvmti_agent.h" 41 #include "../util/jitdump.h" 42 43 #define JIT_LANG "java" 44 45 static char jit_path[PATH_MAX]; 46 static void *marker_addr; 47 48 #ifndef HAVE_GETTID 49 static inline pid_t gettid(void) 50 { 51 return (pid_t)syscall(__NR_gettid); 52 } 53 #endif 54 55 static int get_e_machine(struct jitheader *hdr) 56 { 57 ssize_t sret; 58 char id[16]; 59 int fd, ret = -1; 60 struct { 61 uint16_t e_type; 62 uint16_t e_machine; 63 } info; 64 65 fd = open("/proc/self/exe", O_RDONLY); 66 if (fd == -1) 67 return -1; 68 69 sret = read(fd, id, sizeof(id)); 70 if (sret != sizeof(id)) 71 goto error; 72 73 /* check ELF signature */ 74 if (id[0] != 0x7f || id[1] != 'E' || id[2] != 'L' || id[3] != 'F') 75 goto error; 76 77 sret = read(fd, &info, sizeof(info)); 78 if (sret != sizeof(info)) 79 goto error; 80 81 hdr->elf_mach = info.e_machine; 82 ret = 0; 83 error: 84 close(fd); 85 return ret; 86 } 87 88 static int use_arch_timestamp; 89 90 static inline uint64_t 91 get_arch_timestamp(void) 92 { 93 #if defined(__i386__) || defined(__x86_64__) 94 unsigned int low, high; 95 96 asm volatile("rdtsc" : "=a" (low), "=d" (high)); 97 98 return low | ((uint64_t)high) << 32; 99 #else 100 return 0; 101 #endif 102 } 103 104 #define NSEC_PER_SEC 1000000000 105 static int perf_clk_id = CLOCK_MONOTONIC; 106 107 static inline uint64_t 108 timespec_to_ns(const struct timespec *ts) 109 { 110 return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec; 111 } 112 113 static inline uint64_t 114 perf_get_timestamp(void) 115 { 116 struct timespec ts; 117 int ret; 118 119 if (use_arch_timestamp) 120 return get_arch_timestamp(); 121 122 ret = clock_gettime(perf_clk_id, &ts); 123 if (ret) 124 return 0; 125 126 return timespec_to_ns(&ts); 127 } 128 129 static int 130 create_jit_cache_dir(void) 131 { 132 char str[32]; 133 char *base, *p; 134 struct tm tm; 135 time_t t; 136 int ret; 137 138 time(&t); 139 localtime_r(&t, &tm); 140 141 base = getenv("JITDUMPDIR"); 142 if (!base) 143 base = getenv("HOME"); 144 if (!base) 145 base = "."; 146 147 strftime(str, sizeof(str), JIT_LANG"-jit-%Y%m%d", &tm); 148 149 ret = snprintf(jit_path, PATH_MAX, "%s/.debug/", base); 150 if (ret >= PATH_MAX) { 151 warnx("jvmti: cannot generate jit cache dir because %s/.debug/" 152 " is too long, please check the cwd, JITDUMPDIR, and" 153 " HOME variables", base); 154 return -1; 155 } 156 ret = mkdir(jit_path, 0755); 157 if (ret == -1) { 158 if (errno != EEXIST) { 159 warn("jvmti: cannot create jit cache dir %s", jit_path); 160 return -1; 161 } 162 } 163 164 ret = snprintf(jit_path, PATH_MAX, "%s/.debug/jit", base); 165 if (ret >= PATH_MAX) { 166 warnx("jvmti: cannot generate jit cache dir because" 167 " %s/.debug/jit is too long, please check the cwd," 168 " JITDUMPDIR, and HOME variables", base); 169 return -1; 170 } 171 ret = mkdir(jit_path, 0755); 172 if (ret == -1) { 173 if (errno != EEXIST) { 174 warn("jvmti: cannot create jit cache dir %s", jit_path); 175 return -1; 176 } 177 } 178 179 ret = snprintf(jit_path, PATH_MAX, "%s/.debug/jit/%s.XXXXXXXX", base, str); 180 if (ret >= PATH_MAX) { 181 warnx("jvmti: cannot generate jit cache dir because" 182 " %s/.debug/jit/%s.XXXXXXXX is too long, please check" 183 " the cwd, JITDUMPDIR, and HOME variables", 184 base, str); 185 return -1; 186 } 187 p = mkdtemp(jit_path); 188 if (p != jit_path) { 189 warn("jvmti: cannot create jit cache dir %s", jit_path); 190 return -1; 191 } 192 193 return 0; 194 } 195 196 static int 197 perf_open_marker_file(int fd) 198 { 199 long pgsz; 200 201 pgsz = sysconf(_SC_PAGESIZE); 202 if (pgsz == -1) 203 return -1; 204 205 /* 206 * we mmap the jitdump to create an MMAP RECORD in perf.data file. 207 * The mmap is captured either live (perf record running when we mmap) 208 * or in deferred mode, via /proc/PID/maps 209 * the MMAP record is used as a marker of a jitdump file for more meta 210 * data info about the jitted code. Perf report/annotate detect this 211 * special filename and process the jitdump file. 212 * 213 * mapping must be PROT_EXEC to ensure it is captured by perf record 214 * even when not using -d option 215 */ 216 marker_addr = mmap(NULL, pgsz, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0); 217 return (marker_addr == MAP_FAILED) ? -1 : 0; 218 } 219 220 static void 221 perf_close_marker_file(void) 222 { 223 long pgsz; 224 225 if (!marker_addr) 226 return; 227 228 pgsz = sysconf(_SC_PAGESIZE); 229 if (pgsz == -1) 230 return; 231 232 munmap(marker_addr, pgsz); 233 } 234 235 static void 236 init_arch_timestamp(void) 237 { 238 char *str = getenv("JITDUMP_USE_ARCH_TIMESTAMP"); 239 240 if (!str || !*str || !strcmp(str, "0")) 241 return; 242 243 use_arch_timestamp = 1; 244 } 245 246 void *jvmti_open(void) 247 { 248 char dump_path[PATH_MAX]; 249 struct jitheader header; 250 int fd, ret; 251 FILE *fp; 252 253 init_arch_timestamp(); 254 255 /* 256 * check if clockid is supported 257 */ 258 if (!perf_get_timestamp()) { 259 if (use_arch_timestamp) 260 warnx("jvmti: arch timestamp not supported"); 261 else 262 warnx("jvmti: kernel does not support %d clock id", perf_clk_id); 263 } 264 265 memset(&header, 0, sizeof(header)); 266 267 /* 268 * jitdump file dir 269 */ 270 if (create_jit_cache_dir() < 0) 271 return NULL; 272 273 /* 274 * jitdump file name 275 */ 276 ret = snprintf(dump_path, PATH_MAX, "%s/jit-%i.dump", jit_path, getpid()); 277 if (ret >= PATH_MAX) { 278 warnx("jvmti: cannot generate jitdump file full path because" 279 " %s/jit-%i.dump is too long, please check the cwd," 280 " JITDUMPDIR, and HOME variables", jit_path, getpid()); 281 return NULL; 282 } 283 284 fd = open(dump_path, O_CREAT|O_TRUNC|O_RDWR, 0666); 285 if (fd == -1) 286 return NULL; 287 288 /* 289 * create perf.data maker for the jitdump file 290 */ 291 if (perf_open_marker_file(fd)) { 292 warnx("jvmti: failed to create marker file"); 293 return NULL; 294 } 295 296 fp = fdopen(fd, "w+"); 297 if (!fp) { 298 warn("jvmti: cannot create %s", dump_path); 299 close(fd); 300 goto error; 301 } 302 303 warnx("jvmti: jitdump in %s", dump_path); 304 305 if (get_e_machine(&header)) { 306 warn("get_e_machine failed\n"); 307 goto error; 308 } 309 310 header.magic = JITHEADER_MAGIC; 311 header.version = JITHEADER_VERSION; 312 header.total_size = sizeof(header); 313 header.pid = getpid(); 314 315 header.timestamp = perf_get_timestamp(); 316 317 if (use_arch_timestamp) 318 header.flags |= JITDUMP_FLAGS_ARCH_TIMESTAMP; 319 320 if (!fwrite(&header, sizeof(header), 1, fp)) { 321 warn("jvmti: cannot write dumpfile header"); 322 goto error; 323 } 324 return fp; 325 error: 326 fclose(fp); 327 return NULL; 328 } 329 330 int 331 jvmti_close(void *agent) 332 { 333 struct jr_code_close rec; 334 FILE *fp = agent; 335 336 if (!fp) { 337 warnx("jvmti: invalid fd in close_agent"); 338 return -1; 339 } 340 341 rec.p.id = JIT_CODE_CLOSE; 342 rec.p.total_size = sizeof(rec); 343 344 rec.p.timestamp = perf_get_timestamp(); 345 346 if (!fwrite(&rec, sizeof(rec), 1, fp)) 347 return -1; 348 349 fclose(fp); 350 351 fp = NULL; 352 353 perf_close_marker_file(); 354 355 return 0; 356 } 357 358 int 359 jvmti_write_code(void *agent, char const *sym, 360 uint64_t vma, void const *code, unsigned int const size) 361 { 362 static int code_generation = 1; 363 struct jr_code_load rec; 364 size_t sym_len; 365 FILE *fp = agent; 366 int ret = -1; 367 368 /* don't care about 0 length function, no samples */ 369 if (size == 0) 370 return 0; 371 372 if (!fp) { 373 warnx("jvmti: invalid fd in write_native_code"); 374 return -1; 375 } 376 377 sym_len = strlen(sym) + 1; 378 379 rec.p.id = JIT_CODE_LOAD; 380 rec.p.total_size = sizeof(rec) + sym_len; 381 rec.p.timestamp = perf_get_timestamp(); 382 383 rec.code_size = size; 384 rec.vma = vma; 385 rec.code_addr = vma; 386 rec.pid = getpid(); 387 rec.tid = gettid(); 388 389 if (code) 390 rec.p.total_size += size; 391 392 /* 393 * If JVM is multi-threaded, multiple concurrent calls to agent 394 * may be possible, so protect file writes 395 */ 396 flockfile(fp); 397 398 /* 399 * get code index inside lock to avoid race condition 400 */ 401 rec.code_index = code_generation++; 402 403 ret = fwrite_unlocked(&rec, sizeof(rec), 1, fp); 404 fwrite_unlocked(sym, sym_len, 1, fp); 405 406 if (code) 407 fwrite_unlocked(code, size, 1, fp); 408 409 funlockfile(fp); 410 411 ret = 0; 412 413 return ret; 414 } 415 416 int 417 jvmti_write_debug_info(void *agent, uint64_t code, 418 int nr_lines, jvmti_line_info_t *li, 419 const char * const * file_names) 420 { 421 struct jr_code_debug_info rec; 422 size_t sret, len, size, flen = 0; 423 uint64_t addr; 424 FILE *fp = agent; 425 int i; 426 427 /* 428 * no entry to write 429 */ 430 if (!nr_lines) 431 return 0; 432 433 if (!fp) { 434 warnx("jvmti: invalid fd in write_debug_info"); 435 return -1; 436 } 437 438 for (i = 0; i < nr_lines; ++i) { 439 flen += strlen(file_names[i]) + 1; 440 } 441 442 rec.p.id = JIT_CODE_DEBUG_INFO; 443 size = sizeof(rec); 444 rec.p.timestamp = perf_get_timestamp(); 445 rec.code_addr = (uint64_t)(uintptr_t)code; 446 rec.nr_entry = nr_lines; 447 448 /* 449 * on disk source line info layout: 450 * uint64_t : addr 451 * int : line number 452 * int : column discriminator 453 * file[] : source file name 454 */ 455 size += nr_lines * sizeof(struct debug_entry); 456 size += flen; 457 rec.p.total_size = size; 458 459 /* 460 * If JVM is multi-threaded, multiple concurrent calls to agent 461 * may be possible, so protect file writes 462 */ 463 flockfile(fp); 464 465 sret = fwrite_unlocked(&rec, sizeof(rec), 1, fp); 466 if (sret != 1) 467 goto error; 468 469 for (i = 0; i < nr_lines; i++) { 470 471 addr = (uint64_t)li[i].pc; 472 len = sizeof(addr); 473 sret = fwrite_unlocked(&addr, len, 1, fp); 474 if (sret != 1) 475 goto error; 476 477 len = sizeof(li[0].line_number); 478 sret = fwrite_unlocked(&li[i].line_number, len, 1, fp); 479 if (sret != 1) 480 goto error; 481 482 len = sizeof(li[0].discrim); 483 sret = fwrite_unlocked(&li[i].discrim, len, 1, fp); 484 if (sret != 1) 485 goto error; 486 487 sret = fwrite_unlocked(file_names[i], strlen(file_names[i]) + 1, 1, fp); 488 if (sret != 1) 489 goto error; 490 } 491 funlockfile(fp); 492 return 0; 493 error: 494 funlockfile(fp); 495 return -1; 496 } 497