1209045adSStephane Eranian /* 2209045adSStephane Eranian * jvmti_agent.c: JVMTI agent interface 3209045adSStephane Eranian * 4209045adSStephane Eranian * Adapted from the Oprofile code in opagent.c: 5209045adSStephane Eranian * This library is free software; you can redistribute it and/or 6209045adSStephane Eranian * modify it under the terms of the GNU Lesser General Public 7209045adSStephane Eranian * License as published by the Free Software Foundation; either 8209045adSStephane Eranian * version 2.1 of the License, or (at your option) any later version. 9209045adSStephane Eranian * 10209045adSStephane Eranian * This library is distributed in the hope that it will be useful, 11209045adSStephane Eranian * but WITHOUT ANY WARRANTY; without even the implied warranty of 12209045adSStephane Eranian * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13209045adSStephane Eranian * Lesser General Public License for more details. 14209045adSStephane Eranian * 15209045adSStephane Eranian * You should have received a copy of the GNU Lesser General Public 16209045adSStephane Eranian * License along with this library; if not, write to the Free Software 17209045adSStephane Eranian * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18209045adSStephane Eranian * 19209045adSStephane Eranian * Copyright 2007 OProfile authors 20209045adSStephane Eranian * Jens Wilke 21209045adSStephane Eranian * Daniel Hansel 22209045adSStephane Eranian * Copyright IBM Corporation 2007 23209045adSStephane Eranian */ 24209045adSStephane Eranian #include <sys/types.h> 25209045adSStephane Eranian #include <sys/stat.h> /* for mkdir() */ 26209045adSStephane Eranian #include <stdio.h> 27209045adSStephane Eranian #include <errno.h> 28209045adSStephane Eranian #include <string.h> 29209045adSStephane Eranian #include <stdlib.h> 30209045adSStephane Eranian #include <stdint.h> 31209045adSStephane Eranian #include <limits.h> 32209045adSStephane Eranian #include <fcntl.h> 33209045adSStephane Eranian #include <unistd.h> 34209045adSStephane Eranian #include <time.h> 35209045adSStephane Eranian #include <sys/mman.h> 36209045adSStephane Eranian #include <syscall.h> /* for gettid() */ 37209045adSStephane Eranian #include <err.h> 38209045adSStephane Eranian 39209045adSStephane Eranian #include "jvmti_agent.h" 40209045adSStephane Eranian #include "../util/jitdump.h" 41209045adSStephane Eranian 42209045adSStephane Eranian #define JIT_LANG "java" 43209045adSStephane Eranian 44209045adSStephane Eranian static char jit_path[PATH_MAX]; 45209045adSStephane Eranian static void *marker_addr; 46209045adSStephane Eranian 47209045adSStephane Eranian /* 48209045adSStephane Eranian * padding buffer 49209045adSStephane Eranian */ 50209045adSStephane Eranian static const char pad_bytes[7]; 51209045adSStephane Eranian 52209045adSStephane Eranian static inline pid_t gettid(void) 53209045adSStephane Eranian { 54209045adSStephane Eranian return (pid_t)syscall(__NR_gettid); 55209045adSStephane Eranian } 56209045adSStephane Eranian 57209045adSStephane Eranian static int get_e_machine(struct jitheader *hdr) 58209045adSStephane Eranian { 59209045adSStephane Eranian ssize_t sret; 60209045adSStephane Eranian char id[16]; 61209045adSStephane Eranian int fd, ret = -1; 62209045adSStephane Eranian int m = -1; 63209045adSStephane Eranian struct { 64209045adSStephane Eranian uint16_t e_type; 65209045adSStephane Eranian uint16_t e_machine; 66209045adSStephane Eranian } info; 67209045adSStephane Eranian 68209045adSStephane Eranian fd = open("/proc/self/exe", O_RDONLY); 69209045adSStephane Eranian if (fd == -1) 70209045adSStephane Eranian return -1; 71209045adSStephane Eranian 72209045adSStephane Eranian sret = read(fd, id, sizeof(id)); 73209045adSStephane Eranian if (sret != sizeof(id)) 74209045adSStephane Eranian goto error; 75209045adSStephane Eranian 76209045adSStephane Eranian /* check ELF signature */ 77209045adSStephane Eranian if (id[0] != 0x7f || id[1] != 'E' || id[2] != 'L' || id[3] != 'F') 78209045adSStephane Eranian goto error; 79209045adSStephane Eranian 80209045adSStephane Eranian sret = read(fd, &info, sizeof(info)); 81209045adSStephane Eranian if (sret != sizeof(info)) 82209045adSStephane Eranian goto error; 83209045adSStephane Eranian 84209045adSStephane Eranian m = info.e_machine; 85209045adSStephane Eranian if (m < 0) 86209045adSStephane Eranian m = 0; /* ELF EM_NONE */ 87209045adSStephane Eranian 88209045adSStephane Eranian hdr->elf_mach = m; 89209045adSStephane Eranian ret = 0; 90209045adSStephane Eranian error: 91209045adSStephane Eranian close(fd); 92209045adSStephane Eranian return ret; 93209045adSStephane Eranian } 94209045adSStephane Eranian 95*2a28e230SAdrian Hunter static int use_arch_timestamp; 96*2a28e230SAdrian Hunter 97*2a28e230SAdrian Hunter static inline uint64_t 98*2a28e230SAdrian Hunter get_arch_timestamp(void) 99*2a28e230SAdrian Hunter { 100*2a28e230SAdrian Hunter #if defined(__i386__) || defined(__x86_64__) 101*2a28e230SAdrian Hunter unsigned int low, high; 102*2a28e230SAdrian Hunter 103*2a28e230SAdrian Hunter asm volatile("rdtsc" : "=a" (low), "=d" (high)); 104*2a28e230SAdrian Hunter 105*2a28e230SAdrian Hunter return low | ((uint64_t)high) << 32; 106*2a28e230SAdrian Hunter #else 107*2a28e230SAdrian Hunter return 0; 108*2a28e230SAdrian Hunter #endif 109*2a28e230SAdrian Hunter } 110*2a28e230SAdrian Hunter 111209045adSStephane Eranian #define NSEC_PER_SEC 1000000000 112209045adSStephane Eranian static int perf_clk_id = CLOCK_MONOTONIC; 113209045adSStephane Eranian 114209045adSStephane Eranian static inline uint64_t 115209045adSStephane Eranian timespec_to_ns(const struct timespec *ts) 116209045adSStephane Eranian { 117209045adSStephane Eranian return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec; 118209045adSStephane Eranian } 119209045adSStephane Eranian 120209045adSStephane Eranian static inline uint64_t 121209045adSStephane Eranian perf_get_timestamp(void) 122209045adSStephane Eranian { 123209045adSStephane Eranian struct timespec ts; 124209045adSStephane Eranian int ret; 125209045adSStephane Eranian 126*2a28e230SAdrian Hunter if (use_arch_timestamp) 127*2a28e230SAdrian Hunter return get_arch_timestamp(); 128*2a28e230SAdrian Hunter 129209045adSStephane Eranian ret = clock_gettime(perf_clk_id, &ts); 130209045adSStephane Eranian if (ret) 131209045adSStephane Eranian return 0; 132209045adSStephane Eranian 133209045adSStephane Eranian return timespec_to_ns(&ts); 134209045adSStephane Eranian } 135209045adSStephane Eranian 136209045adSStephane Eranian static int 137209045adSStephane Eranian debug_cache_init(void) 138209045adSStephane Eranian { 139209045adSStephane Eranian char str[32]; 140209045adSStephane Eranian char *base, *p; 141209045adSStephane Eranian struct tm tm; 142209045adSStephane Eranian time_t t; 143209045adSStephane Eranian int ret; 144209045adSStephane Eranian 145209045adSStephane Eranian time(&t); 146209045adSStephane Eranian localtime_r(&t, &tm); 147209045adSStephane Eranian 148209045adSStephane Eranian base = getenv("JITDUMPDIR"); 149209045adSStephane Eranian if (!base) 150209045adSStephane Eranian base = getenv("HOME"); 151209045adSStephane Eranian if (!base) 152209045adSStephane Eranian base = "."; 153209045adSStephane Eranian 154209045adSStephane Eranian strftime(str, sizeof(str), JIT_LANG"-jit-%Y%m%d", &tm); 155209045adSStephane Eranian 156209045adSStephane Eranian snprintf(jit_path, PATH_MAX - 1, "%s/.debug/", base); 157209045adSStephane Eranian 158209045adSStephane Eranian ret = mkdir(jit_path, 0755); 159209045adSStephane Eranian if (ret == -1) { 160209045adSStephane Eranian if (errno != EEXIST) { 161209045adSStephane Eranian warn("jvmti: cannot create jit cache dir %s", jit_path); 162209045adSStephane Eranian return -1; 163209045adSStephane Eranian } 164209045adSStephane Eranian } 165209045adSStephane Eranian 166209045adSStephane Eranian snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit", base); 167209045adSStephane Eranian ret = mkdir(jit_path, 0755); 168209045adSStephane Eranian if (ret == -1) { 169209045adSStephane Eranian if (errno != EEXIST) { 170209045adSStephane Eranian warn("cannot create jit cache dir %s", jit_path); 171209045adSStephane Eranian return -1; 172209045adSStephane Eranian } 173209045adSStephane Eranian } 174209045adSStephane Eranian 175209045adSStephane Eranian snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit/%s.XXXXXXXX", base, str); 176209045adSStephane Eranian 177209045adSStephane Eranian p = mkdtemp(jit_path); 178209045adSStephane Eranian if (p != jit_path) { 179209045adSStephane Eranian warn("cannot create jit cache dir %s", jit_path); 180209045adSStephane Eranian return -1; 181209045adSStephane Eranian } 182209045adSStephane Eranian 183209045adSStephane Eranian return 0; 184209045adSStephane Eranian } 185209045adSStephane Eranian 186209045adSStephane Eranian static int 187209045adSStephane Eranian perf_open_marker_file(int fd) 188209045adSStephane Eranian { 189209045adSStephane Eranian long pgsz; 190209045adSStephane Eranian 191209045adSStephane Eranian pgsz = sysconf(_SC_PAGESIZE); 192209045adSStephane Eranian if (pgsz == -1) 193209045adSStephane Eranian return -1; 194209045adSStephane Eranian 195209045adSStephane Eranian /* 196209045adSStephane Eranian * we mmap the jitdump to create an MMAP RECORD in perf.data file. 197209045adSStephane Eranian * The mmap is captured either live (perf record running when we mmap) 198209045adSStephane Eranian * or in deferred mode, via /proc/PID/maps 199209045adSStephane Eranian * the MMAP record is used as a marker of a jitdump file for more meta 200209045adSStephane Eranian * data info about the jitted code. Perf report/annotate detect this 201209045adSStephane Eranian * special filename and process the jitdump file. 202209045adSStephane Eranian * 203209045adSStephane Eranian * mapping must be PROT_EXEC to ensure it is captured by perf record 204209045adSStephane Eranian * even when not using -d option 205209045adSStephane Eranian */ 206209045adSStephane Eranian marker_addr = mmap(NULL, pgsz, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0); 207209045adSStephane Eranian return (marker_addr == MAP_FAILED) ? -1 : 0; 208209045adSStephane Eranian } 209209045adSStephane Eranian 210209045adSStephane Eranian static void 211209045adSStephane Eranian perf_close_marker_file(void) 212209045adSStephane Eranian { 213209045adSStephane Eranian long pgsz; 214209045adSStephane Eranian 215209045adSStephane Eranian if (!marker_addr) 216209045adSStephane Eranian return; 217209045adSStephane Eranian 218209045adSStephane Eranian pgsz = sysconf(_SC_PAGESIZE); 219209045adSStephane Eranian if (pgsz == -1) 220209045adSStephane Eranian return; 221209045adSStephane Eranian 222209045adSStephane Eranian munmap(marker_addr, pgsz); 223209045adSStephane Eranian } 224209045adSStephane Eranian 225*2a28e230SAdrian Hunter static void 226*2a28e230SAdrian Hunter init_arch_timestamp(void) 227*2a28e230SAdrian Hunter { 228*2a28e230SAdrian Hunter char *str = getenv("JITDUMP_USE_ARCH_TIMESTAMP"); 229*2a28e230SAdrian Hunter 230*2a28e230SAdrian Hunter if (!str || !*str || !strcmp(str, "0")) 231*2a28e230SAdrian Hunter return; 232*2a28e230SAdrian Hunter 233*2a28e230SAdrian Hunter use_arch_timestamp = 1; 234*2a28e230SAdrian Hunter } 235*2a28e230SAdrian Hunter 236209045adSStephane Eranian void *jvmti_open(void) 237209045adSStephane Eranian { 238209045adSStephane Eranian int pad_cnt; 239209045adSStephane Eranian char dump_path[PATH_MAX]; 240209045adSStephane Eranian struct jitheader header; 241209045adSStephane Eranian int fd; 242209045adSStephane Eranian FILE *fp; 243209045adSStephane Eranian 244*2a28e230SAdrian Hunter init_arch_timestamp(); 245*2a28e230SAdrian Hunter 246209045adSStephane Eranian /* 247209045adSStephane Eranian * check if clockid is supported 248209045adSStephane Eranian */ 249*2a28e230SAdrian Hunter if (!perf_get_timestamp()) { 250*2a28e230SAdrian Hunter if (use_arch_timestamp) 251*2a28e230SAdrian Hunter warnx("jvmti: arch timestamp not supported"); 252*2a28e230SAdrian Hunter else 253209045adSStephane Eranian warnx("jvmti: kernel does not support %d clock id", perf_clk_id); 254*2a28e230SAdrian Hunter } 255209045adSStephane Eranian 256209045adSStephane Eranian memset(&header, 0, sizeof(header)); 257209045adSStephane Eranian 258209045adSStephane Eranian debug_cache_init(); 259209045adSStephane Eranian 260209045adSStephane Eranian /* 261209045adSStephane Eranian * jitdump file name 262209045adSStephane Eranian */ 263209045adSStephane Eranian snprintf(dump_path, PATH_MAX, "%s/jit-%i.dump", jit_path, getpid()); 264209045adSStephane Eranian 265209045adSStephane Eranian fd = open(dump_path, O_CREAT|O_TRUNC|O_RDWR, 0666); 266209045adSStephane Eranian if (fd == -1) 267209045adSStephane Eranian return NULL; 268209045adSStephane Eranian 269209045adSStephane Eranian /* 270209045adSStephane Eranian * create perf.data maker for the jitdump file 271209045adSStephane Eranian */ 272209045adSStephane Eranian if (perf_open_marker_file(fd)) { 273209045adSStephane Eranian warnx("jvmti: failed to create marker file"); 274209045adSStephane Eranian return NULL; 275209045adSStephane Eranian } 276209045adSStephane Eranian 277209045adSStephane Eranian fp = fdopen(fd, "w+"); 278209045adSStephane Eranian if (!fp) { 279209045adSStephane Eranian warn("jvmti: cannot create %s", dump_path); 280209045adSStephane Eranian close(fd); 281209045adSStephane Eranian goto error; 282209045adSStephane Eranian } 283209045adSStephane Eranian 284209045adSStephane Eranian warnx("jvmti: jitdump in %s", dump_path); 285209045adSStephane Eranian 286209045adSStephane Eranian if (get_e_machine(&header)) { 287209045adSStephane Eranian warn("get_e_machine failed\n"); 288209045adSStephane Eranian goto error; 289209045adSStephane Eranian } 290209045adSStephane Eranian 291209045adSStephane Eranian header.magic = JITHEADER_MAGIC; 292209045adSStephane Eranian header.version = JITHEADER_VERSION; 293209045adSStephane Eranian header.total_size = sizeof(header); 294209045adSStephane Eranian header.pid = getpid(); 295209045adSStephane Eranian 296209045adSStephane Eranian /* calculate amount of padding '\0' */ 297209045adSStephane Eranian pad_cnt = PADDING_8ALIGNED(header.total_size); 298209045adSStephane Eranian header.total_size += pad_cnt; 299209045adSStephane Eranian 300209045adSStephane Eranian header.timestamp = perf_get_timestamp(); 301209045adSStephane Eranian 302*2a28e230SAdrian Hunter if (use_arch_timestamp) 303*2a28e230SAdrian Hunter header.flags |= JITDUMP_FLAGS_ARCH_TIMESTAMP; 304*2a28e230SAdrian Hunter 305209045adSStephane Eranian if (!fwrite(&header, sizeof(header), 1, fp)) { 306209045adSStephane Eranian warn("jvmti: cannot write dumpfile header"); 307209045adSStephane Eranian goto error; 308209045adSStephane Eranian } 309209045adSStephane Eranian 310209045adSStephane Eranian /* write padding '\0' if necessary */ 311209045adSStephane Eranian if (pad_cnt && !fwrite(pad_bytes, pad_cnt, 1, fp)) { 312209045adSStephane Eranian warn("jvmti: cannot write dumpfile header padding"); 313209045adSStephane Eranian goto error; 314209045adSStephane Eranian } 315209045adSStephane Eranian 316209045adSStephane Eranian return fp; 317209045adSStephane Eranian error: 318209045adSStephane Eranian fclose(fp); 319209045adSStephane Eranian return NULL; 320209045adSStephane Eranian } 321209045adSStephane Eranian 322209045adSStephane Eranian int 323209045adSStephane Eranian jvmti_close(void *agent) 324209045adSStephane Eranian { 325209045adSStephane Eranian struct jr_code_close rec; 326209045adSStephane Eranian FILE *fp = agent; 327209045adSStephane Eranian 328209045adSStephane Eranian if (!fp) { 329209045adSStephane Eranian warnx("jvmti: incalid fd in close_agent"); 330209045adSStephane Eranian return -1; 331209045adSStephane Eranian } 332209045adSStephane Eranian 333209045adSStephane Eranian rec.p.id = JIT_CODE_CLOSE; 334209045adSStephane Eranian rec.p.total_size = sizeof(rec); 335209045adSStephane Eranian 336209045adSStephane Eranian rec.p.timestamp = perf_get_timestamp(); 337209045adSStephane Eranian 338209045adSStephane Eranian if (!fwrite(&rec, sizeof(rec), 1, fp)) 339209045adSStephane Eranian return -1; 340209045adSStephane Eranian 341209045adSStephane Eranian fclose(fp); 342209045adSStephane Eranian 343209045adSStephane Eranian fp = NULL; 344209045adSStephane Eranian 345209045adSStephane Eranian perf_close_marker_file(); 346209045adSStephane Eranian 347209045adSStephane Eranian return 0; 348209045adSStephane Eranian } 349209045adSStephane Eranian 350209045adSStephane Eranian int 351209045adSStephane Eranian jvmti_write_code(void *agent, char const *sym, 352209045adSStephane Eranian uint64_t vma, void const *code, unsigned int const size) 353209045adSStephane Eranian { 354209045adSStephane Eranian static int code_generation = 1; 355209045adSStephane Eranian struct jr_code_load rec; 356209045adSStephane Eranian size_t sym_len; 357209045adSStephane Eranian size_t padding_count; 358209045adSStephane Eranian FILE *fp = agent; 359209045adSStephane Eranian int ret = -1; 360209045adSStephane Eranian 361209045adSStephane Eranian /* don't care about 0 length function, no samples */ 362209045adSStephane Eranian if (size == 0) 363209045adSStephane Eranian return 0; 364209045adSStephane Eranian 365209045adSStephane Eranian if (!fp) { 366209045adSStephane Eranian warnx("jvmti: invalid fd in write_native_code"); 367209045adSStephane Eranian return -1; 368209045adSStephane Eranian } 369209045adSStephane Eranian 370209045adSStephane Eranian sym_len = strlen(sym) + 1; 371209045adSStephane Eranian 372209045adSStephane Eranian rec.p.id = JIT_CODE_LOAD; 373209045adSStephane Eranian rec.p.total_size = sizeof(rec) + sym_len; 374209045adSStephane Eranian padding_count = PADDING_8ALIGNED(rec.p.total_size); 375209045adSStephane Eranian rec.p. total_size += padding_count; 376209045adSStephane Eranian rec.p.timestamp = perf_get_timestamp(); 377209045adSStephane Eranian 378209045adSStephane Eranian rec.code_size = size; 379209045adSStephane Eranian rec.vma = vma; 380209045adSStephane Eranian rec.code_addr = vma; 381209045adSStephane Eranian rec.pid = getpid(); 382209045adSStephane Eranian rec.tid = gettid(); 383209045adSStephane Eranian 384209045adSStephane Eranian if (code) 385209045adSStephane Eranian rec.p.total_size += size; 386209045adSStephane Eranian 387209045adSStephane Eranian /* 388209045adSStephane Eranian * If JVM is multi-threaded, nultiple concurrent calls to agent 389209045adSStephane Eranian * may be possible, so protect file writes 390209045adSStephane Eranian */ 391209045adSStephane Eranian flockfile(fp); 392209045adSStephane Eranian 393209045adSStephane Eranian /* 394209045adSStephane Eranian * get code index inside lock to avoid race condition 395209045adSStephane Eranian */ 396209045adSStephane Eranian rec.code_index = code_generation++; 397209045adSStephane Eranian 398209045adSStephane Eranian ret = fwrite_unlocked(&rec, sizeof(rec), 1, fp); 399209045adSStephane Eranian fwrite_unlocked(sym, sym_len, 1, fp); 400209045adSStephane Eranian 401209045adSStephane Eranian if (padding_count) 402209045adSStephane Eranian fwrite_unlocked(pad_bytes, padding_count, 1, fp); 403209045adSStephane Eranian 404209045adSStephane Eranian if (code) 405209045adSStephane Eranian fwrite_unlocked(code, size, 1, fp); 406209045adSStephane Eranian 407209045adSStephane Eranian funlockfile(fp); 408209045adSStephane Eranian 409209045adSStephane Eranian ret = 0; 410209045adSStephane Eranian 411209045adSStephane Eranian return ret; 412209045adSStephane Eranian } 413209045adSStephane Eranian 414209045adSStephane Eranian int 415209045adSStephane Eranian jvmti_write_debug_info(void *agent, uint64_t code, const char *file, 416598b7c69SStephane Eranian jvmti_line_info_t *li, int nr_lines) 417209045adSStephane Eranian { 418209045adSStephane Eranian struct jr_code_debug_info rec; 419209045adSStephane Eranian size_t sret, len, size, flen; 420209045adSStephane Eranian size_t padding_count; 421598b7c69SStephane Eranian uint64_t addr; 422598b7c69SStephane Eranian const char *fn = file; 423209045adSStephane Eranian FILE *fp = agent; 424209045adSStephane Eranian int i; 425209045adSStephane Eranian 426209045adSStephane Eranian /* 427209045adSStephane Eranian * no entry to write 428209045adSStephane Eranian */ 429598b7c69SStephane Eranian if (!nr_lines) 430209045adSStephane Eranian return 0; 431209045adSStephane Eranian 432209045adSStephane Eranian if (!fp) { 433209045adSStephane Eranian warnx("jvmti: invalid fd in write_debug_info"); 434209045adSStephane Eranian return -1; 435209045adSStephane Eranian } 436209045adSStephane Eranian 437209045adSStephane Eranian flen = strlen(file) + 1; 438209045adSStephane Eranian 439209045adSStephane Eranian rec.p.id = JIT_CODE_DEBUG_INFO; 440209045adSStephane Eranian size = sizeof(rec); 441209045adSStephane Eranian rec.p.timestamp = perf_get_timestamp(); 442209045adSStephane Eranian rec.code_addr = (uint64_t)(uintptr_t)code; 443598b7c69SStephane Eranian rec.nr_entry = nr_lines; 444209045adSStephane Eranian 445209045adSStephane Eranian /* 446209045adSStephane Eranian * on disk source line info layout: 447209045adSStephane Eranian * uint64_t : addr 448209045adSStephane Eranian * int : line number 449598b7c69SStephane Eranian * int : column discriminator 450209045adSStephane Eranian * file[] : source file name 451209045adSStephane Eranian * padding : pad to multiple of 8 bytes 452209045adSStephane Eranian */ 453598b7c69SStephane Eranian size += nr_lines * sizeof(struct debug_entry); 454598b7c69SStephane Eranian size += flen * nr_lines; 455209045adSStephane Eranian /* 456209045adSStephane Eranian * pad to 8 bytes 457209045adSStephane Eranian */ 458209045adSStephane Eranian padding_count = PADDING_8ALIGNED(size); 459209045adSStephane Eranian 460209045adSStephane Eranian rec.p.total_size = size + padding_count; 461209045adSStephane Eranian 462209045adSStephane Eranian /* 463209045adSStephane Eranian * If JVM is multi-threaded, nultiple concurrent calls to agent 464209045adSStephane Eranian * may be possible, so protect file writes 465209045adSStephane Eranian */ 466209045adSStephane Eranian flockfile(fp); 467209045adSStephane Eranian 468209045adSStephane Eranian sret = fwrite_unlocked(&rec, sizeof(rec), 1, fp); 469209045adSStephane Eranian if (sret != 1) 470209045adSStephane Eranian goto error; 471209045adSStephane Eranian 472598b7c69SStephane Eranian for (i = 0; i < nr_lines; i++) { 473209045adSStephane Eranian 474598b7c69SStephane Eranian addr = (uint64_t)li[i].pc; 475209045adSStephane Eranian len = sizeof(addr); 476209045adSStephane Eranian sret = fwrite_unlocked(&addr, len, 1, fp); 477209045adSStephane Eranian if (sret != 1) 478209045adSStephane Eranian goto error; 479209045adSStephane Eranian 480598b7c69SStephane Eranian len = sizeof(li[0].line_number); 481209045adSStephane Eranian sret = fwrite_unlocked(&li[i].line_number, len, 1, fp); 482209045adSStephane Eranian if (sret != 1) 483209045adSStephane Eranian goto error; 484209045adSStephane Eranian 485598b7c69SStephane Eranian len = sizeof(li[0].discrim); 486598b7c69SStephane Eranian sret = fwrite_unlocked(&li[i].discrim, len, 1, fp); 487209045adSStephane Eranian if (sret != 1) 488209045adSStephane Eranian goto error; 489209045adSStephane Eranian 490598b7c69SStephane Eranian sret = fwrite_unlocked(fn, flen, 1, fp); 491598b7c69SStephane Eranian if (sret != 1) 492598b7c69SStephane Eranian goto error; 493209045adSStephane Eranian } 494209045adSStephane Eranian if (padding_count) 495209045adSStephane Eranian sret = fwrite_unlocked(pad_bytes, padding_count, 1, fp); 496209045adSStephane Eranian if (sret != 1) 497209045adSStephane Eranian goto error; 498209045adSStephane Eranian 499209045adSStephane Eranian funlockfile(fp); 500209045adSStephane Eranian return 0; 501209045adSStephane Eranian error: 502209045adSStephane Eranian funlockfile(fp); 503209045adSStephane Eranian return -1; 504209045adSStephane Eranian } 505