perf tools: add JVMTI agent library

ARCH=$(shell uname -m)

ifeq ($(ARCH), x86_64)

JARCH=amd64

endif

ifeq ($(ARCH), armv7l)

JARCH=armhf

endif

ifeq ($(ARCH), armv6l)

JARCH=armhf

endif

ifeq ($(ARCH), aarch64)

JARCH=aarch64

endif

ifeq ($(ARCH), ppc64)

JARCH=powerpc

endif

ifeq ($(ARCH), ppc64le)

JARCH=powerpc

endif

DESTDIR=/usr/local

VERSION=1

REVISION=0

AGE=0

LN=ln -sf

RM=rm

SLIBJVMTI=libjvmti.so.$(VERSION).$(REVISION).$(AGE)

VLIBJVMTI=libjvmti.so.$(VERSION)

SLDFLAGS=-shared -Wl,-soname -Wl,$(VLIBJVMTI)

SOLIBEXT=so

# The following works at least on fedora 23, you may need the next

# line for other distros.

JDIR=$(shell alternatives --display java | tail -1 | cut -d' ' -f 5 | sed 's%/jre/bin/java.%%g')

#JDIR=$(shell /usr/sbin/update-java-alternatives -l | head -1 | cut -d ' ' -f 3)

# -lrt required in 32-bit mode for clock_gettime()

LIBS=-lelf -lrt

INCDIR=-I $(JDIR)/include -I $(JDIR)/include/linux

TARGETS=$(SLIBJVMTI)

SRCS=libjvmti.c jvmti_agent.c

OBJS=$(SRCS:.c=.o)

SOBJS=$(OBJS:.o=.lo)

OPT=-O2 -g -Werror -Wall

CFLAGS=$(INCDIR) $(OPT)

all: $(TARGETS)

.c.o:

	$(CC) $(CFLAGS) -c $*.c

.c.lo:

	$(CC) -fPIC -DPIC $(CFLAGS) -c $*.c -o $*.lo

$(OBJS) $(SOBJS): Makefile jvmti_agent.h ../util/jitdump.h

$(SLIBJVMTI):  $(SOBJS)

	$(CC) $(CFLAGS) $(SLDFLAGS)  -o $@ $(SOBJS) $(LIBS)

	$(LN) $@ libjvmti.$(SOLIBEXT)

clean:

	$(RM) -f *.o *.so.* *.so *.lo

install:

	-mkdir -p $(DESTDIR)/lib

	install -m 755 $(SLIBJVMTI) $(DESTDIR)/lib/

	(cd $(DESTDIR)/lib; $(LN) $(SLIBJVMTI) $(VLIBJVMTI))

	(cd $(DESTDIR)/lib; $(LN) $(SLIBJVMTI) libjvmti.$(SOLIBEXT))

	ldconfig

.SUFFIXES: .c .S .o .lo

/*

 * jvmti_agent.c: JVMTI agent interface

 *

 * Adapted from the Oprofile code in opagent.c:

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Copyright 2007 OProfile authors

 * Jens Wilke

 * Daniel Hansel

 * Copyright IBM Corporation 2007

 */

#include <sys/types.h>

#include <sys/stat.h> /* for mkdir() */

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#include <stdint.h>

#include <limits.h>

#include <fcntl.h>

#include <unistd.h>

#include <time.h>

#include <sys/mman.h>

#include <syscall.h> /* for gettid() */

#include <err.h>

#include "jvmti_agent.h"

#include "../util/jitdump.h"

#define JIT_LANG "java"

static char jit_path[PATH_MAX];

static void *marker_addr;

/*

 * padding buffer

 */

static const char pad_bytes[7];

static inline pid_t gettid(void)

{

	return (pid_t)syscall(__NR_gettid);

}

static int get_e_machine(struct jitheader *hdr)

{

	ssize_t sret;

	char id[16];

	int fd, ret = -1;

	int m = -1;

	struct {

		uint16_t e_type;

		uint16_t e_machine;

	} info;

	fd = open("/proc/self/exe", O_RDONLY);

	if (fd == -1)

		return -1;

	sret = read(fd, id, sizeof(id));

	if (sret != sizeof(id))

		goto error;

	/* check ELF signature */

	if (id[0] != 0x7f || id[1] != 'E' || id[2] != 'L' || id[3] != 'F')

		goto error;

	sret = read(fd, &info, sizeof(info));

	if (sret != sizeof(info))

		goto error;

	m = info.e_machine;

	if (m < 0)

		m = 0; /* ELF EM_NONE */

	hdr->elf_mach = m;

	ret = 0;

error:

	close(fd);

	return ret;

}

#define NSEC_PER_SEC	1000000000

static int perf_clk_id = CLOCK_MONOTONIC;

static inline uint64_t

timespec_to_ns(const struct timespec *ts)

{

        return ((uint64_t) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;

}

static inline uint64_t

perf_get_timestamp(void)

{

	struct timespec ts;

	int ret;

	ret = clock_gettime(perf_clk_id, &ts);

	if (ret)

		return 0;

	return timespec_to_ns(&ts);

}

static int

debug_cache_init(void)

{

	char str[32];

	char *base, *p;

	struct tm tm;

	time_t t;

	int ret;

	time(&t);

	localtime_r(&t, &tm);

	base = getenv("JITDUMPDIR");

	if (!base)

		base = getenv("HOME");

	if (!base)

		base = ".";

	strftime(str, sizeof(str), JIT_LANG"-jit-%Y%m%d", &tm);

	snprintf(jit_path, PATH_MAX - 1, "%s/.debug/", base);

	ret = mkdir(jit_path, 0755);

	if (ret == -1) {

		if (errno != EEXIST) {

			warn("jvmti: cannot create jit cache dir %s", jit_path);

			return -1;

		}

	}

	snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit", base);

	ret = mkdir(jit_path, 0755);

	if (ret == -1) {

		if (errno != EEXIST) {

			warn("cannot create jit cache dir %s", jit_path);

			return -1;

		}

	}

	snprintf(jit_path, PATH_MAX - 1, "%s/.debug/jit/%s.XXXXXXXX", base, str);

	p = mkdtemp(jit_path);

	if (p != jit_path) {

		warn("cannot create jit cache dir %s", jit_path);

		return -1;

	}

	return 0;

}

static int

perf_open_marker_file(int fd)

{

	long pgsz;

	pgsz = sysconf(_SC_PAGESIZE);

	if (pgsz == -1)

		return -1;

	/*

	 * we mmap the jitdump to create an MMAP RECORD in perf.data file.

	 * The mmap is captured either live (perf record running when we mmap)

	 * or  in deferred mode, via /proc/PID/maps

	 * the MMAP record is used as a marker of a jitdump file for more meta

	 * data info about the jitted code. Perf report/annotate detect this

	 * special filename and process the jitdump file.

	 *

	 * mapping must be PROT_EXEC to ensure it is captured by perf record

	 * even when not using -d option

	 */

	marker_addr = mmap(NULL, pgsz, PROT_READ|PROT_EXEC, MAP_PRIVATE, fd, 0);

	return (marker_addr == MAP_FAILED) ? -1 : 0;

}

static void

perf_close_marker_file(void)

{

	long pgsz;

	if (!marker_addr)

		return;

	pgsz = sysconf(_SC_PAGESIZE);

	if (pgsz == -1)

		return;

	munmap(marker_addr, pgsz);

}

void *jvmti_open(void)

{

	int pad_cnt;

	char dump_path[PATH_MAX];

	struct jitheader header;

	int fd;

	FILE *fp;

	/*

	 * check if clockid is supported

	 */

	if (!perf_get_timestamp())

		warnx("jvmti: kernel does not support %d clock id", perf_clk_id);

	memset(&header, 0, sizeof(header));

	debug_cache_init();

	/*

	 * jitdump file name

	 */

	snprintf(dump_path, PATH_MAX, "%s/jit-%i.dump", jit_path, getpid());

	fd = open(dump_path, O_CREAT|O_TRUNC|O_RDWR, 0666);

	if (fd == -1)

		return NULL;

	/*

	 * create perf.data maker for the jitdump file

	 */

	if (perf_open_marker_file(fd)) {

		warnx("jvmti: failed to create marker file");

		return NULL;

	}

	fp = fdopen(fd, "w+");

	if (!fp) {

		warn("jvmti: cannot create %s", dump_path);

		close(fd);

		goto error;

	}

	warnx("jvmti: jitdump in %s", dump_path);

	if (get_e_machine(&header)) {

		warn("get_e_machine failed\n");

		goto error;

	}

	header.magic      = JITHEADER_MAGIC;

	header.version    = JITHEADER_VERSION;

	header.total_size = sizeof(header);

	header.pid        = getpid();

	/* calculate amount of padding '\0' */

	pad_cnt = PADDING_8ALIGNED(header.total_size);

	header.total_size += pad_cnt;

	header.timestamp = perf_get_timestamp();

	if (!fwrite(&header, sizeof(header), 1, fp)) {

		warn("jvmti: cannot write dumpfile header");

		goto error;

	}

	/* write padding '\0' if necessary */

	if (pad_cnt && !fwrite(pad_bytes, pad_cnt, 1, fp)) {

		warn("jvmti: cannot write dumpfile header padding");

		goto error;

	}

	return fp;

error:

	fclose(fp);

	return NULL;

}

int

jvmti_close(void *agent)

{

	struct jr_code_close rec;

	FILE *fp = agent;

	if (!fp) {

		warnx("jvmti: incalid fd in close_agent");

		return -1;

	}

	rec.p.id = JIT_CODE_CLOSE;

	rec.p.total_size = sizeof(rec);

	rec.p.timestamp = perf_get_timestamp();

	if (!fwrite(&rec, sizeof(rec), 1, fp))

		return -1;

	fclose(fp);

	fp = NULL;

	perf_close_marker_file();

	return 0;

}

int

jvmti_write_code(void *agent, char const *sym,

	uint64_t vma, void const *code, unsigned int const size)

{

	static int code_generation = 1;

	struct jr_code_load rec;

	size_t sym_len;

	size_t padding_count;

	FILE *fp = agent;

	int ret = -1;

	/* don't care about 0 length function, no samples */

	if (size == 0)

		return 0;

	if (!fp) {

		warnx("jvmti: invalid fd in write_native_code");

		return -1;

	}

	sym_len = strlen(sym) + 1;

	rec.p.id           = JIT_CODE_LOAD;

	rec.p.total_size   = sizeof(rec) + sym_len;

	padding_count      = PADDING_8ALIGNED(rec.p.total_size);

	rec.p. total_size += padding_count;

	rec.p.timestamp    = perf_get_timestamp();

	rec.code_size  = size;

	rec.vma        = vma;

	rec.code_addr  = vma;

	rec.pid	       = getpid();

	rec.tid	       = gettid();

	if (code)

		rec.p.total_size += size;

	/*

	 * If JVM is multi-threaded, nultiple concurrent calls to agent

	 * may be possible, so protect file writes

	 */

	flockfile(fp);

	/*

	 * get code index inside lock to avoid race condition

	 */

	rec.code_index = code_generation++;

	ret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);

	fwrite_unlocked(sym, sym_len, 1, fp);

	if (padding_count)

		fwrite_unlocked(pad_bytes, padding_count, 1, fp);

	if (code)

		fwrite_unlocked(code, size, 1, fp);

	funlockfile(fp);

	ret = 0;

	return ret;

}

int

jvmti_write_debug_info(void *agent, uint64_t code, const char *file,

		       jvmtiAddrLocationMap const *map,

		       jvmtiLineNumberEntry *li, jint num)

{

	static const char *prev_str = "\xff";

	struct jr_code_debug_info rec;

	size_t sret, len, size, flen;

	size_t padding_count;

	FILE *fp = agent;

	int i;

	/*

	 * no entry to write

	 */

	if (!num)

		return 0;

	if (!fp) {

		warnx("jvmti: invalid fd in write_debug_info");

		return -1;

	}

	flen = strlen(file) + 1;

	rec.p.id        = JIT_CODE_DEBUG_INFO;

	size            = sizeof(rec);

	rec.p.timestamp = perf_get_timestamp();

	rec.code_addr   = (uint64_t)(uintptr_t)code;

	rec.nr_entry    = num;

	/*

	 * on disk source line info layout:

	 * uint64_t : addr

	 * int      : line number

	 * file[]   : source file name

	 * padding  : pad to multiple of 8 bytes

	 */

	size += num * (sizeof(uint64_t) + sizeof(int));

	size += flen + (num - 1) * 2;

	/*

	 * pad to 8 bytes

	 */

	padding_count = PADDING_8ALIGNED(size);

	rec.p.total_size = size + padding_count;

	/*

	 * If JVM is multi-threaded, nultiple concurrent calls to agent

	 * may be possible, so protect file writes

	 */

	flockfile(fp);

	sret = fwrite_unlocked(&rec, sizeof(rec), 1, fp);

	if (sret != 1)

		goto error;

	for (i = 0; i < num; i++) {

		uint64_t addr;

		addr = (uint64_t)map[i].start_address;

		len  = sizeof(addr);

		sret = fwrite_unlocked(&addr, len, 1, fp);

		if (sret != 1)

			goto error;

		len  = sizeof(int);

		sret = fwrite_unlocked(&li[i].line_number, len, 1, fp);

		if (sret != 1)

			goto error;

		if (i == 0) {

			sret = fwrite_unlocked(file, flen, 1, fp);

		} else {

			sret = fwrite_unlocked(prev_str, 2, 1, fp);

		}

		if (sret != 1)

			goto error;

	}

	if (padding_count)

		sret = fwrite_unlocked(pad_bytes, padding_count, 1, fp);

		if (sret != 1)

			goto error;

	funlockfile(fp);

	return 0;

error:

	funlockfile(fp);

	return -1;

}

#ifndef __JVMTI_AGENT_H__

#define __JVMTI_AGENT_H__

#include <sys/types.h>

#include <stdint.h>

#include <jvmti.h>

#define __unused __attribute__((unused))

#if defined(__cplusplus)

extern "C" {

#endif

void *jvmti_open(void);

int   jvmti_close(void *agent);

int   jvmti_write_code(void *agent, char const *symbol_name,

		       uint64_t vma, void const *code,

		       const unsigned int code_size);

int   jvmti_write_debug_info(void *agent,

		             uint64_t code,

			     const char *file,

			     jvmtiAddrLocationMap const *map,

			     jvmtiLineNumberEntry *tab, jint nr);

#if defined(__cplusplus)

}

#endif

#endif /* __JVMTI_H__ */

#include <sys/types.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <err.h>

#include <jvmti.h>

#include <limits.h>

#include "jvmti_agent.h"

static int has_line_numbers;

void *jvmti_agent;

static void JNICALL

compiled_method_load_cb(jvmtiEnv *jvmti,

			jmethodID method,

			jint code_size,

			void const *code_addr,

			jint map_length,

			jvmtiAddrLocationMap const *map,

			void const *compile_info __unused)

{

	jvmtiLineNumberEntry *tab = NULL;

	jclass decl_class;

	char *class_sign = NULL;

	char *func_name = NULL;

	char *func_sign = NULL;

	char *file_name= NULL;

	char fn[PATH_MAX];

	uint64_t addr = (uint64_t)(uintptr_t)code_addr;

	jvmtiError ret;

	jint nr_lines = 0;

	size_t len;

	ret = (*jvmti)->GetMethodDeclaringClass(jvmti, method,

						&decl_class);

	if (ret != JVMTI_ERROR_NONE) {

		warnx("jvmti: cannot get declaring class");

		return;

	}

	if (has_line_numbers && map && map_length) {

		ret = (*jvmti)->GetLineNumberTable(jvmti, method, &nr_lines, &tab);

		if (ret != JVMTI_ERROR_NONE) {

			warnx("jvmti: cannot get line table for method");

		} else {

			ret = (*jvmti)->GetSourceFileName(jvmti, decl_class, &file_name);

			if (ret != JVMTI_ERROR_NONE) {

				warnx("jvmti: cannot get source filename ret=%d", ret);

				nr_lines = 0;

			}

		}

	}

	ret = (*jvmti)->GetClassSignature(jvmti, decl_class,

					  &class_sign, NULL);

	if (ret != JVMTI_ERROR_NONE) {

		warnx("jvmti: getclassignature failed");

		goto error;

	}

	ret = (*jvmti)->GetMethodName(jvmti, method, &func_name,

				      &func_sign, NULL);

	if (ret != JVMTI_ERROR_NONE) {

		warnx("jvmti: failed getmethodname");

		goto error;

	}

	/*

	 * Assume path name is class hierarchy, this is a common practice with Java programs

	 */

	if (*class_sign == 'L') {

		int j, i = 0;

		char *p = strrchr(class_sign, '/');

		if (p) {

			/* drop the 'L' prefix and copy up to the final '/' */

			for (i = 0; i < (p - class_sign); i++)

				fn[i] = class_sign[i+1];

		}

		/*

		 * append file name, we use loops and not string ops to avoid modifying

		 * class_sign which is used later for the symbol name

		 */

		for (j = 0; i < (PATH_MAX - 1) && file_name && j < strlen(file_name); j++, i++)

			fn[i] = file_name[j];

		fn[i] = '\0';

	} else {

		/* fallback case */

		strcpy(fn, file_name);

	}

	/*

	 * write source line info record if we have it

	 */

	if (jvmti_write_debug_info(jvmti_agent, addr, fn, map, tab, nr_lines))

		warnx("jvmti: write_debug_info() failed");

	len = strlen(func_name) + strlen(class_sign) + strlen(func_sign) + 2;

	{

		char str[len];

		snprintf(str, len, "%s%s%s", class_sign, func_name, func_sign);

		if (jvmti_write_code(jvmti_agent, str, addr, code_addr, code_size))

			warnx("jvmti: write_code() failed");

	}

error:

	(*jvmti)->Deallocate(jvmti, (unsigned char *)func_name);

	(*jvmti)->Deallocate(jvmti, (unsigned char *)func_sign);

	(*jvmti)->Deallocate(jvmti, (unsigned char *)class_sign);

	(*jvmti)->Deallocate(jvmti, (unsigned char *)tab);

	(*jvmti)->Deallocate(jvmti, (unsigned char *)file_name);

}

static void JNICALL

code_generated_cb(jvmtiEnv *jvmti,

		  char const *name,

		  void const *code_addr,

		  jint code_size)

{

	uint64_t addr = (uint64_t)(unsigned long)code_addr;

	int ret;

	ret = jvmti_write_code(jvmti_agent, name, addr, code_addr, code_size);

	if (ret)

		warnx("jvmti: write_code() failed for code_generated");

}

JNIEXPORT jint JNICALL

Agent_OnLoad(JavaVM *jvm, char *options, void *reserved __unused)

{

	jvmtiEventCallbacks cb;

	jvmtiCapabilities caps1;

	jvmtiJlocationFormat format;

	jvmtiEnv *jvmti = NULL;

	jint ret;

	jvmti_agent = jvmti_open();

	if (!jvmti_agent) {

		warnx("jvmti: open_agent failed");

		return -1;

	}

	/*

	 * Request a JVMTI interface version 1 environment

	 */

	ret = (*jvm)->GetEnv(jvm, (void *)&jvmti, JVMTI_VERSION_1);

	if (ret != JNI_OK) {