[mirror_ubuntu-zesty-kernel.git] / tools / perf / jvmti / libjvmti.c

#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <err.h>
#include <jvmti.h>
#include <jvmticmlr.h>
#include <limits.h>

#include "jvmti_agent.h"

static int has_line_numbers;
void *jvmti_agent;

static jvmtiError
do_get_line_numbers(jvmtiEnv *jvmti, void *pc, jmethodID m, jint bci,
		    jvmti_line_info_t *tab, jint *nr)
{
	jint i, lines = 0;
	jint nr_lines = 0;
	jvmtiLineNumberEntry *loc_tab = NULL;
	jvmtiError ret;

	ret = (*jvmti)->GetLineNumberTable(jvmti, m, &nr_lines, &loc_tab);
	if (ret != JVMTI_ERROR_NONE)
		return ret;

	for (i = 0; i < nr_lines; i++) {
		if (loc_tab[i].start_location < bci) {
			tab[lines].pc = (unsigned long)pc;
			tab[lines].line_number = loc_tab[i].line_number;
			tab[lines].discrim = 0; /* not yet used */
			lines++;
		} else {
			break;
		}
	}
	(*jvmti)->Deallocate(jvmti, (unsigned char *)loc_tab);
	*nr = lines;
	return JVMTI_ERROR_NONE;
}

static jvmtiError
get_line_numbers(jvmtiEnv *jvmti, const void *compile_info, jvmti_line_info_t **tab, int *nr_lines)
{
	const jvmtiCompiledMethodLoadRecordHeader *hdr;
	jvmtiCompiledMethodLoadInlineRecord *rec;
	jvmtiLineNumberEntry *lne = NULL;
	PCStackInfo *c;
	jint nr, ret;
	int nr_total = 0;
	int i, lines_total = 0;

	if (!(tab && nr_lines))
		return JVMTI_ERROR_NULL_POINTER;

	/*
	 * Phase 1 -- get the number of lines necessary
	 */
	for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
		if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
			rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
			for (i = 0; i < rec->numpcs; i++) {
				c = rec->pcinfo + i;
				nr = 0;
				/*
				 * unfortunately, need a tab to get the number of lines!
				 */
				ret = (*jvmti)->GetLineNumberTable(jvmti, c->methods[0], &nr, &lne);
				if (ret == JVMTI_ERROR_NONE) {
					/* free what was allocated for nothing */
					(*jvmti)->Deallocate(jvmti, (unsigned char *)lne);
					nr_total += (int)nr;
				}
			}
		}
	}

	if (nr_total == 0)
		return JVMTI_ERROR_NOT_FOUND;

	/*
	 * Phase 2 -- allocate big enough line table
	 */
	*tab = malloc(nr_total * sizeof(**tab));
	if (!*tab)
		return JVMTI_ERROR_OUT_OF_MEMORY;

	for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
		if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
			rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
			for (i = 0; i < rec->numpcs; i++) {
				c = rec->pcinfo + i;
				nr = 0;
				ret = do_get_line_numbers(jvmti, c->pc,
							  c->methods[0],
							  c->bcis[0],
							  *tab + lines_total,
							  &nr);
				if (ret == JVMTI_ERROR_NONE)
					lines_total += nr;
			}
		}
	}
	*nr_lines = lines_total;
	return JVMTI_ERROR_NONE;
}

static void JNICALL
compiled_method_load_cb(jvmtiEnv *jvmti,
			jmethodID method,
			jint code_size,
			void const *code_addr,
			jint map_length,
			jvmtiAddrLocationMap const *map,
			const void *compile_info)
{
	jvmti_line_info_t *line_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;
	int nr_lines = 0; /* in line_tab[] */
	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 = get_line_numbers(jvmti, compile_info, &line_tab, &nr_lines);
		if (ret != JVMTI_ERROR_NONE) {
			warnx("jvmti: cannot get line table for method");
			nr_lines = 0;
		}
	}

	ret = (*jvmti)->GetSourceFileName(jvmti, decl_class, &file_name);
	if (ret != JVMTI_ERROR_NONE) {
		warnx("jvmti: cannot get source filename ret=%d", ret);
		goto error;
	}

	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, line_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 *)file_name);
	free(line_tab);
}

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) {
		warnx("jvmti: jvmti version 1 not supported");
		return -1;
	}

	/*
	 * acquire method_load capability, we require it
	 * request line numbers (optional)
	 */
	memset(&caps1, 0, sizeof(caps1));
	caps1.can_generate_compiled_method_load_events = 1;

	ret = (*jvmti)->AddCapabilities(jvmti, &caps1);
	if (ret != JVMTI_ERROR_NONE) {
		warnx("jvmti: acquire compiled_method capability failed");
		return -1;
	}
	ret = (*jvmti)->GetJLocationFormat(jvmti, &format);
        if (ret == JVMTI_ERROR_NONE && format == JVMTI_JLOCATION_JVMBCI) {
                memset(&caps1, 0, sizeof(caps1));
                caps1.can_get_line_numbers = 1;
                caps1.can_get_source_file_name = 1;
		ret = (*jvmti)->AddCapabilities(jvmti, &caps1);
                if (ret == JVMTI_ERROR_NONE)
                        has_line_numbers = 1;
        }

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

	cb.CompiledMethodLoad   = compiled_method_load_cb;
	cb.DynamicCodeGenerated = code_generated_cb;

	ret = (*jvmti)->SetEventCallbacks(jvmti, &cb, sizeof(cb));
	if (ret != JVMTI_ERROR_NONE) {
		warnx("jvmti: cannot set event callbacks");
		return -1;
	}

	ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
			JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
	if (ret != JVMTI_ERROR_NONE) {
		warnx("jvmti: setnotification failed for method_load");
		return -1;
	}

	ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
			JVMTI_EVENT_DYNAMIC_CODE_GENERATED, NULL);
	if (ret != JVMTI_ERROR_NONE) {
		warnx("jvmti: setnotification failed on code_generated");
		return -1;
	}
	return 0;
}

JNIEXPORT void JNICALL
Agent_OnUnload(JavaVM *jvm __unused)
{
	int ret;

	ret = jvmti_close(jvmti_agent);
	if (ret)
		errx(1, "Error: op_close_agent()");
}
Commit	Line	Data
209045ad SE	1	#include <sys/types.h>
	2	#include <stdio.h>
	3	#include <string.h>
	4	#include <stdlib.h>
	5	#include <err.h>
	6	#include <jvmti.h>
598b7c69	7	#include <jvmticmlr.h>
209045ad SE	8	#include <limits.h>
	9
	10	#include "jvmti_agent.h"
	11
	12	static int has_line_numbers;
	13	void *jvmti_agent;
	14
598b7c69 SE	15	static jvmtiError
	16	do_get_line_numbers(jvmtiEnv jvmti, void pc, jmethodID m, jint bci,
	17	jvmti_line_info_t tab, jint nr)
	18	{
	19	jint i, lines = 0;
	20	jint nr_lines = 0;
	21	jvmtiLineNumberEntry *loc_tab = NULL;
	22	jvmtiError ret;
	23
	24	ret = (*jvmti)->GetLineNumberTable(jvmti, m, &nr_lines, &loc_tab);
	25	if (ret != JVMTI_ERROR_NONE)
	26	return ret;
	27
	28	for (i = 0; i < nr_lines; i++) {
	29	if (loc_tab[i].start_location < bci) {
	30	tab[lines].pc = (unsigned long)pc;
	31	tab[lines].line_number = loc_tab[i].line_number;
	32	tab[lines].discrim = 0; /* not yet used */
	33	lines++;
	34	} else {
	35	break;
	36	}
	37	}
	38	(jvmti)->Deallocate(jvmti, (unsigned char )loc_tab);
	39	*nr = lines;
	40	return JVMTI_ERROR_NONE;
	41	}
	42
	43	static jvmtiError
	44	get_line_numbers(jvmtiEnv jvmti, const void compile_info, jvmti_line_info_t *tab, int nr_lines)
	45	{
	46	const jvmtiCompiledMethodLoadRecordHeader *hdr;
	47	jvmtiCompiledMethodLoadInlineRecord *rec;
	48	jvmtiLineNumberEntry *lne = NULL;
	49	PCStackInfo *c;
	50	jint nr, ret;
	51	int nr_total = 0;
	52	int i, lines_total = 0;
	53
	54	if (!(tab && nr_lines))
	55	return JVMTI_ERROR_NULL_POINTER;
	56
	57	/*
	58	* Phase 1 -- get the number of lines necessary
	59	*/
	60	for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
	61	if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
	62	rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
	63	for (i = 0; i < rec->numpcs; i++) {
	64	c = rec->pcinfo + i;
	65	nr = 0;
	66	/*
	67	* unfortunately, need a tab to get the number of lines!
	68	*/
	69	ret = (*jvmti)->GetLineNumberTable(jvmti, c->methods[0], &nr, &lne);
	70	if (ret == JVMTI_ERROR_NONE) {
	71	/* free what was allocated for nothing */
	72	(jvmti)->Deallocate(jvmti, (unsigned char )lne);
	73	nr_total += (int)nr;
	74	}
	75	}
	76	}
	77	}
	78
79	if (nr_total == 0)
80	return JVMTI_ERROR_NOT_FOUND;
81
82	/*
83	* Phase 2 -- allocate big enough line table
84	*/
85	tab = malloc(nr_total sizeof(**tab));
86	if (!*tab)
87	return JVMTI_ERROR_OUT_OF_MEMORY;
88
89	for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
90	if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
91	rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
92	for (i = 0; i < rec->numpcs; i++) {
93	c = rec->pcinfo + i;
94	nr = 0;
95	ret = do_get_line_numbers(jvmti, c->pc,
96	c->methods[0],
97	c->bcis[0],
98	*tab + lines_total,
99	&nr);
100	if (ret == JVMTI_ERROR_NONE)
101	lines_total += nr;
102	}
103	}
104	}
105	*nr_lines = lines_total;
106	return JVMTI_ERROR_NONE;
107	}
108
209045ad SE	109	static void JNICALL
	110	compiled_method_load_cb(jvmtiEnv *jvmti,
	111	jmethodID method,
	112	jint code_size,
	113	void const *code_addr,
	114	jint map_length,
	115	jvmtiAddrLocationMap const *map,
598b7c69	116	const void *compile_info)
209045ad	117	{
598b7c69	118	jvmti_line_info_t *line_tab = NULL;
209045ad SE	119	jclass decl_class;
	120	char *class_sign = NULL;
	121	char *func_name = NULL;
	122	char *func_sign = NULL;
	123	char *file_name= NULL;
	124	char fn[PATH_MAX];
	125	uint64_t addr = (uint64_t)(uintptr_t)code_addr;
	126	jvmtiError ret;
598b7c69	127	int nr_lines = 0; /* in line_tab[] */
209045ad SE	128	size_t len;
	129
	130	ret = (*jvmti)->GetMethodDeclaringClass(jvmti, method,
	131	&decl_class);
	132	if (ret != JVMTI_ERROR_NONE) {
	133	warnx("jvmti: cannot get declaring class");
	134	return;
	135	}
	136
	137	if (has_line_numbers && map && map_length) {
598b7c69	138	ret = get_line_numbers(jvmti, compile_info, &line_tab, &nr_lines);
209045ad SE	139	if (ret != JVMTI_ERROR_NONE) {
209045ad SE	140	warnx("jvmti: cannot get line table for method");
598b7c69	141	nr_lines = 0;
209045ad SE	142	}
	143	}
	144
598b7c69 SE	145	ret = (*jvmti)->GetSourceFileName(jvmti, decl_class, &file_name);
	146	if (ret != JVMTI_ERROR_NONE) {
	147	warnx("jvmti: cannot get source filename ret=%d", ret);
	148	goto error;
	149	}
	150
209045ad SE	151	ret = (*jvmti)->GetClassSignature(jvmti, decl_class,
	152	&class_sign, NULL);
	153	if (ret != JVMTI_ERROR_NONE) {
	154	warnx("jvmti: getclassignature failed");
	155	goto error;
	156	}
	157
	158	ret = (*jvmti)->GetMethodName(jvmti, method, &func_name,
	159	&func_sign, NULL);
	160	if (ret != JVMTI_ERROR_NONE) {
	161	warnx("jvmti: failed getmethodname");
	162	goto error;
	163	}
	164
	165	/*
	166	* Assume path name is class hierarchy, this is a common practice with Java programs
	167	*/
	168	if (*class_sign == 'L') {
	169	int j, i = 0;
	170	char *p = strrchr(class_sign, '/');
	171	if (p) {
	172	/* drop the 'L' prefix and copy up to the final '/' */
	173	for (i = 0; i < (p - class_sign); i++)
	174	fn[i] = class_sign[i+1];
	175	}
	176	/*
	177	* append file name, we use loops and not string ops to avoid modifying
	178	* class_sign which is used later for the symbol name
	179	*/
	180	for (j = 0; i < (PATH_MAX - 1) && file_name && j < strlen(file_name); j++, i++)
	181	fn[i] = file_name[j];
	182	fn[i] = '\0';
	183	} else {
	184	/* fallback case */
	185	strcpy(fn, file_name);
	186	}
	187	/*
	188	* write source line info record if we have it
	189	*/
598b7c69	190	if (jvmti_write_debug_info(jvmti_agent, addr, fn, line_tab, nr_lines))
209045ad SE	191	warnx("jvmti: write_debug_info() failed");
	192
	193	len = strlen(func_name) + strlen(class_sign) + strlen(func_sign) + 2;
	194	{
	195	char str[len];
	196	snprintf(str, len, "%s%s%s", class_sign, func_name, func_sign);
598b7c69	197
209045ad SE	198	if (jvmti_write_code(jvmti_agent, str, addr, code_addr, code_size))
	199	warnx("jvmti: write_code() failed");
	200	}
	201	error:
	202	(jvmti)->Deallocate(jvmti, (unsigned char )func_name);
	203	(jvmti)->Deallocate(jvmti, (unsigned char )func_sign);
	204	(jvmti)->Deallocate(jvmti, (unsigned char )class_sign);
209045ad	205	(jvmti)->Deallocate(jvmti, (unsigned char )file_name);
598b7c69	206	free(line_tab);
209045ad SE	207	}
	208
	209	static void JNICALL
	210	code_generated_cb(jvmtiEnv *jvmti,
	211	char const *name,
	212	void const *code_addr,
	213	jint code_size)
	214	{
	215	uint64_t addr = (uint64_t)(unsigned long)code_addr;
	216	int ret;
	217
	218	ret = jvmti_write_code(jvmti_agent, name, addr, code_addr, code_size);
	219	if (ret)
	220	warnx("jvmti: write_code() failed for code_generated");
	221	}
	222
	223	JNIEXPORT jint JNICALL
	224	Agent_OnLoad(JavaVM jvm, char options, void *reserved __unused)
	225	{
	226	jvmtiEventCallbacks cb;
	227	jvmtiCapabilities caps1;
	228	jvmtiJlocationFormat format;
	229	jvmtiEnv *jvmti = NULL;
	230	jint ret;
	231
	232	jvmti_agent = jvmti_open();
	233	if (!jvmti_agent) {
	234	warnx("jvmti: open_agent failed");
	235	return -1;
	236	}
	237
	238	/*
	239	* Request a JVMTI interface version 1 environment
	240	*/
	241	ret = (jvm)->GetEnv(jvm, (void )&jvmti, JVMTI_VERSION_1);
	242	if (ret != JNI_OK) {
	243	warnx("jvmti: jvmti version 1 not supported");
	244	return -1;
	245	}
	246
	247	/*
	248	* acquire method_load capability, we require it
	249	* request line numbers (optional)
	250	*/
	251	memset(&caps1, 0, sizeof(caps1));
	252	caps1.can_generate_compiled_method_load_events = 1;
	253
	254	ret = (*jvmti)->AddCapabilities(jvmti, &caps1);
	255	if (ret != JVMTI_ERROR_NONE) {
	256	warnx("jvmti: acquire compiled_method capability failed");
	257	return -1;
	258	}
	259	ret = (*jvmti)->GetJLocationFormat(jvmti, &format);
	260	if (ret == JVMTI_ERROR_NONE && format == JVMTI_JLOCATION_JVMBCI) {
	261	memset(&caps1, 0, sizeof(caps1));
	262	caps1.can_get_line_numbers = 1;
	263	caps1.can_get_source_file_name = 1;
	264	ret = (*jvmti)->AddCapabilities(jvmti, &caps1);
	265	if (ret == JVMTI_ERROR_NONE)
	266	has_line_numbers = 1;
	267	}
	268
	269	memset(&cb, 0, sizeof(cb));
	270
271	cb.CompiledMethodLoad = compiled_method_load_cb;
272	cb.DynamicCodeGenerated = code_generated_cb;
273
274	ret = (*jvmti)->SetEventCallbacks(jvmti, &cb, sizeof(cb));
275	if (ret != JVMTI_ERROR_NONE) {
276	warnx("jvmti: cannot set event callbacks");
277	return -1;
278	}
279
280	ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
281	JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
282	if (ret != JVMTI_ERROR_NONE) {
283	warnx("jvmti: setnotification failed for method_load");
284	return -1;
285	}
286
287	ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
288	JVMTI_EVENT_DYNAMIC_CODE_GENERATED, NULL);
289	if (ret != JVMTI_ERROR_NONE) {
290	warnx("jvmti: setnotification failed on code_generated");
291	return -1;
292	}
293	return 0;
294	}
295
296	JNIEXPORT void JNICALL
297	Agent_OnUnload(JavaVM *jvm __unused)
298	{
299	int ret;
300
301	ret = jvmti_close(jvmti_agent);
302	if (ret)
303	errx(1, "Error: op_close_agent()");
304	}