linux/tools/perf/jvmti/jvmti_agent.c
<<
>>
Prefs
   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
  45static char jit_path[PATH_MAX];
  46static void *marker_addr;
  47
  48#ifndef HAVE_GETTID
  49static inline pid_t gettid(void)
  50{
  51        return (pid_t)syscall(__NR_gettid);
  52}
  53#endif
  54
  55static 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;
  83error:
  84        close(fd);
  85        return ret;
  86}
  87
  88static int use_arch_timestamp;
  89
  90static inline uint64_t
  91get_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
 105static int perf_clk_id = CLOCK_MONOTONIC;
 106
 107static inline uint64_t
 108timespec_to_ns(const struct timespec *ts)
 109{
 110        return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
 111}
 112
 113static inline uint64_t
 114perf_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
 129static int
 130create_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
 196static int
 197perf_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
 220static void
 221perf_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
 235static void
 236init_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
 246void *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;
 325error:
 326        fclose(fp);
 327        return NULL;
 328}
 329
 330int
 331jvmti_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
 358int
 359jvmti_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, nultiple 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
 416int
 417jvmti_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, nultiple 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;
 493error:
 494        funlockfile(fp);
 495        return -1;
 496}
 497