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: &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(buf: jit_path, PATH_MAX, fmt: "%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(buf: jit_path, PATH_MAX, fmt: "%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(buf: jit_path, PATH_MAX, fmt: "%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 ; |
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(buf: dump_path, PATH_MAX, fmt: "%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(hdr: &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 | |