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