[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 void print_error(jvmtiEnv *jvmti, const char *msg, jvmtiError ret)
{
	char *err_msg = NULL;
	jvmtiError err;
	err = (*jvmti)->GetErrorName(jvmti, ret, &err_msg);
	if (err == JVMTI_ERROR_NONE) {
		warnx("%s failed with %s", msg, err_msg);
		(*jvmti)->Deallocate(jvmti, (unsigned char *)err_msg);
	} else {
		warnx("%s failed with an unknown error %d", msg, ret);
	}
}

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) {
		print_error(jvmti, "GetLineNumberTable", ret);
		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;
				} else {
					print_error(jvmti, "GetLineNumberTable", ret);
				}
			}
		}
	}

	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) {
		print_error(jvmti, "GetMethodDeclaringClass", ret);
		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) {
		print_error(jvmti, "GetSourceFileName", ret);
		goto error;
	}

	ret = (*jvmti)->GetClassSignature(jvmti, decl_class,
					  &class_sign, NULL);
	if (ret != JVMTI_ERROR_NONE) {
		print_error(jvmti, "GetClassSignature", ret);
		goto error;
	}

	ret = (*jvmti)->GetMethodName(jvmti, method, &func_name,
				      &func_sign, NULL);
	if (ret != JVMTI_ERROR_NONE) {
		print_error(jvmti, "GetMethodName", ret);
		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) {
		print_error(jvmti, "AddCapabilities", ret);
		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;
        } else if (ret != JVMTI_ERROR_NONE)
		print_error(jvmti, "GetJLocationFormat", ret);


	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) {
		print_error(jvmti, "SetEventCallbacks", ret);
		return -1;
	}

	ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
			JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
	if (ret != JVMTI_ERROR_NONE) {
		print_error(jvmti, "SetEventNotificationMode(METHOD_LOAD)", ret);
		return -1;
	}

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