Macintosh-Tools/Retro68
1
0
Fork 0
mirror of https://github.com/autc04/Retro68.git synced 2024-12-03 10:49:58 +00:00
Code Issues Projects Releases Wiki Activity
d0bc757570
Retro68/binutils/gprofng/libcollector/jprofile.c
Wolfgang Thaller f485e125c4 binutils 2.39
2022-10-27 20:45:45 +02:00

1316 lines
45 KiB
C
Raw Blame History

/* Copyright (C) 2021 Free Software Foundation, Inc.
Contributed by Oracle.
This file is part of GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "config.h"
#if defined(GPROFNG_JAVA_PROFILING)
#include <alloca.h>
#include <dlfcn.h> /* dlsym() */
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/param.h> /* MAXPATHLEN */
#include <jni.h>
#include <jvmti.h>
#include "gp-defs.h"
#include "collector.h"
#include "gp-experiment.h"
#include "tsd.h"
/* TprintfT(<level>,...) definitions. Adjust per module as needed */
#define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings
#define DBG_LT1 1 // for configuration details, warnings
#define DBG_LT2 2
#define DBG_LT3 3
/* ARCH_STRLEN is defined in dbe, copied here */
#define ARCH_STRLEN(s) ((CALL_UTIL(strlen)(s) + 4 ) & ~0x3)
/* call frame */
typedef struct
{
jint lineno; /* line number in the source file */
jmethodID method_id; /* method executed in this frame */
} JVMPI_CallFrame;
/* call trace */
typedef struct
{
JNIEnv *env_id; /* Env where trace was recorded */
jint num_frames; /* number of frames in this trace */
JVMPI_CallFrame *frames; /* frames */
} JVMPI_CallTrace;
extern void __collector_jprofile_enable_synctrace (void);
int __collector_jprofile_start_attach (void);
static int init_interface (CollectorInterface*);
static int open_experiment (const char *);
static int close_experiment (void);
static int detach_experiment (void);
static void jprof_find_asyncgetcalltrace (void);
static char *apistr = NULL;
static ModuleInterface module_interface = {
"*"SP_JCLASSES_FILE, /* description, exempt from limit */
init_interface, /* initInterface */
open_experiment, /* openExperiment */
NULL, /* startDataCollection */
NULL, /* stopDataCollection */
close_experiment, /* closeExperiment */
detach_experiment /* detachExperiment (fork child) */
};
static CollectorInterface *collector_interface = NULL;
static CollectorModule jprof_hndl = COLLECTOR_MODULE_ERR;
static int __collector_java_attach = 0;
static JavaVM *jvm;
static jmethodID getResource = NULL;
static jmethodID toExternalForm = NULL;
/* Java profiling thread specific data */
typedef struct TSD_Entry
{
JNIEnv *env;
hrtime_t tstamp;
} TSD_Entry;
static unsigned tsd_key = COLLECTOR_TSD_INVALID_KEY;
static collector_mutex_t jclasses_lock = COLLECTOR_MUTEX_INITIALIZER;
static int java_gc_on = 0;
static int java_mem_mode = 0;
static int java_sync_mode = 0;
static int is_hotspot_vm = 0;
static void get_jvm_settings ();
static void rwrite (int fd, const void *buf, size_t nbyte);
static void addToDynamicArchive (const char* name, const unsigned char* class_data, int class_data_len);
static void (*AsyncGetCallTrace)(JVMPI_CallTrace*, jint, ucontext_t*) = NULL;
static void (*collector_heap_record)(int, int, void*) = NULL;
static void (*collector_jsync_begin)() = NULL;
static void (*collector_jsync_end)(hrtime_t, void *) = NULL;
#define gethrtime collector_interface->getHiResTime
/*
* JVMTI declarations
*/
static jvmtiEnv *jvmti;
static void jvmti_VMInit (jvmtiEnv*, JNIEnv*, jthread);
static void jvmti_VMDeath (jvmtiEnv*, JNIEnv*);
static void jvmti_ThreadStart (jvmtiEnv*, JNIEnv*, jthread);
static void jvmti_ThreadEnd (jvmtiEnv*, JNIEnv*, jthread);
static void jvmti_CompiledMethodLoad (jvmtiEnv*, jmethodID, jint, const void*,
jint, const jvmtiAddrLocationMap*, const void*);
static void jvmti_CompiledMethodUnload (jvmtiEnv*, jmethodID, const void*);
static void jvmti_DynamicCodeGenerated (jvmtiEnv*, const char*, const void*, jint);
static void jvmti_ClassPrepare (jvmtiEnv*, JNIEnv*, jthread, jclass);
static void jvmti_ClassLoad (jvmtiEnv*, JNIEnv*, jthread, jclass);
//static void jvmti_ClassUnload( jvmtiEnv*, JNIEnv*, jthread, jclass );
static void jvmti_MonitorEnter (jvmtiEnv *, JNIEnv*, jthread, jobject);
static void jvmti_MonitorEntered (jvmtiEnv *, JNIEnv*, jthread, jobject);
#if 0
static void jvmti_MonitorWait (jvmtiEnv *, JNIEnv*, jthread, jobject, jlong);
static void jvmti_MonitorWaited (jvmtiEnv *, JNIEnv*, jthread, jobject, jboolean);
#endif
static void jvmti_ClassFileLoadHook (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jclass class_being_redefined,
jobject loader, const char* name, jobject protection_domain,
jint class_data_len, const unsigned char* class_data,
jint* new_class_data_len, unsigned char** new_class_data);
static void jvmti_GarbageCollectionStart (jvmtiEnv *);
static void
jvmti_GarbageCollectionFinish (jvmtiEnv *);
jvmtiEventCallbacks callbacks = {
jvmti_VMInit, // 50 jvmtiEventVMInit;
jvmti_VMDeath, // 51 jvmtiEventVMDeath;
jvmti_ThreadStart, // 52 jvmtiEventThreadStart;
jvmti_ThreadEnd, // 53 jvmtiEventThreadEnd;
jvmti_ClassFileLoadHook, // 54 jvmtiEventClassFileLoadHook;
jvmti_ClassLoad, // 55 jvmtiEventClassLoad;
jvmti_ClassPrepare, // 56 jvmtiEventClassPrepare;
NULL, // 57 reserved57;
NULL, // 58 jvmtiEventException;
NULL, // 59 jvmtiEventExceptionCatch;
NULL, // 60 jvmtiEventSingleStep;
NULL, // 61 jvmtiEventFramePop;
NULL, // 62 jvmtiEventBreakpoint;
NULL, // 63 jvmtiEventFieldAccess;
NULL, // 64 jvmtiEventFieldModification;
NULL, // 65 jvmtiEventMethodEntry;
NULL, // 66 jvmtiEventMethodExit;
NULL, // 67 jvmtiEventNativeMethodBind;
jvmti_CompiledMethodLoad, // 68 jvmtiEventCompiledMethodLoad;
jvmti_CompiledMethodUnload, // 69 jvmtiEventCompiledMethodUnload;
jvmti_DynamicCodeGenerated, // 70 jvmtiEventDynamicCodeGenerated;
NULL, // 71 jvmtiEventDataDumpRequest;
NULL, // 72 jvmtiEventDataResetRequest;
NULL, /*jvmti_MonitorWait,*/ // 73 jvmtiEventMonitorWait;
NULL, /*jvmti_MonitorWaited,*/ // 74 jvmtiEventMonitorWaited;
jvmti_MonitorEnter, // 75 jvmtiEventMonitorContendedEnter;
jvmti_MonitorEntered, // 76 jvmtiEventMonitorContendedEntered;
NULL, // 77 jvmtiEventMonitorContendedExit;
NULL, // 78 jvmtiEventReserved;
NULL, // 79 jvmtiEventReserved;
NULL, // 80 jvmtiEventReserved;
jvmti_GarbageCollectionStart, // 81 jvmtiEventGarbageCollectionStart;
jvmti_GarbageCollectionFinish, // 82 jvmtiEventGarbageCollectionFinish;
NULL, // 83 jvmtiEventObjectFree;
NULL // 84 jvmtiEventVMObjectAlloc;
};
typedef jint (JNICALL JNI_GetCreatedJavaVMs_t)(JavaVM **, jsize, jsize *);
int
init_interface (CollectorInterface *_collector_interface)
{
collector_interface = _collector_interface;
return COL_ERROR_NONE;
}
static int
open_experiment (const char *exp)
{
if (collector_interface == NULL)
return COL_ERROR_JAVAINIT;
TprintfT (0, "jprofile: open_experiment %s\n", exp);
const char *params = collector_interface->getParams ();
const char *args = params;
while (args)
{
if (__collector_strStartWith (args, "j:") == 0)
{
args += 2;
break;
}
args = CALL_UTIL (strchr)(args, ';');
if (args)
args++;
}
if (args == NULL) /* Java profiling not specified */
return COL_ERROR_JAVAINIT;
tsd_key = collector_interface->createKey (sizeof ( TSD_Entry), NULL, NULL);
if (tsd_key == (unsigned) - 1)
{
TprintfT (0, "jprofile: TSD key create failed.\n");
collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">TSD key not created</event>\n",
SP_JCMD_CERROR, COL_ERROR_JAVAINIT);
return COL_ERROR_JAVAINIT;
}
else
Tprintf (DBG_LT2, "jprofile: TSD key create succeeded %d.\n", tsd_key);
args = params;
while (args)
{
if (__collector_strStartWith (args, "H:") == 0)
{
java_mem_mode = 1;
collector_heap_record = (void(*)(int, int, void*))dlsym (RTLD_DEFAULT, "__collector_heap_record");
}
#if 0
else if (__collector_strStartWith (args, "s:") == 0)
{
java_sync_mode = 1;
collector_jsync_begin = (void(*)(hrtime_t, void *))dlsym (RTLD_DEFAULT, "__collector_jsync_begin");
collector_jsync_end = (void(*)(hrtime_t, void *))dlsym (RTLD_DEFAULT, "__collector_jsync_end");
}
#endif
args = CALL_UTIL (strchr)(args, ';');
if (args)
args++;
}
/* synchronization tracing is enabled by the synctrace module, later in initialization */
__collector_java_mode = 1;
java_gc_on = 1;
return COL_ERROR_NONE;
}
/* routine called from the syntrace module to enable Java-API synctrace */
void
__collector_jprofile_enable_synctrace ()
{
if (__collector_java_mode == 0)
{
TprintfT (DBG_LT1, "jprofile: not turning on Java synctrace; Java mode not enabled\n");
return;
}
java_sync_mode = 1;
collector_jsync_begin = (void(*)(hrtime_t, void *))dlsym (RTLD_DEFAULT, "__collector_jsync_begin");
collector_jsync_end = (void(*)(hrtime_t, void *))dlsym (RTLD_DEFAULT, "__collector_jsync_end");
TprintfT (DBG_LT1, "jprofile: turning on Java synctrace, and requesting events\n");
}
int
__collector_jprofile_start_attach (void)
{
if (!__collector_java_mode || __collector_java_asyncgetcalltrace_loaded)
return 0;
void *g_sHandle = RTLD_DEFAULT;
/* Now get the function addresses */
JNI_GetCreatedJavaVMs_t *pfnGetCreatedJavaVMs;
pfnGetCreatedJavaVMs = (JNI_GetCreatedJavaVMs_t *) dlsym (g_sHandle, "JNI_GetCreatedJavaVMs");
if (pfnGetCreatedJavaVMs != NULL)
{
TprintfT (0, "jprofile attach: pfnGetCreatedJavaVMs is detected.\n");
JavaVM * vmBuf[1]; // XXXX only detect on jvm
jsize nVMs = 0;
(*pfnGetCreatedJavaVMs)(vmBuf, 1, &nVMs);
if (vmBuf[0] != NULL && nVMs > 0)
{
jvm = vmBuf[0];
JNIEnv* jni_env = NULL;
(*jvm)->AttachCurrentThread (jvm, (void **) &jni_env, NULL);
Agent_OnLoad (jvm, NULL, NULL);
if ((*jvm)->GetEnv (jvm, (void **) &jni_env, JNI_VERSION_1_2) >= 0 && jni_env && jvmti)
{
jthread thread;
(*jvmti)->GetCurrentThread (jvmti, &thread);
#ifdef DEBUG
collector_thread_t tid;
tid = __collector_thr_self ();
TprintfT (0, "jprofile attach: AttachCurrentThread: thread: %lu jni_env=%p jthread=%p\n",
(unsigned long) tid, jni_env, thread);
#endif /* DEBUG */
jvmti_VMInit (jvmti, jni_env, thread);
(*jvmti)->GenerateEvents (jvmti, JVMTI_EVENT_COMPILED_METHOD_LOAD);
(*jvmti)->GenerateEvents (jvmti, JVMTI_EVENT_DYNAMIC_CODE_GENERATED);
__collector_java_attach = 1;
(*jvm)->DetachCurrentThread (jvm);
}
}
}
return 0;
}
static int
close_experiment (void)
{
/* fixme XXXXX add content here */
/* see detach_experiment() */
__collector_java_mode = 0;
__collector_java_asyncgetcalltrace_loaded = 0;
__collector_java_attach = 0;
java_gc_on = 0;
java_mem_mode = 0;
java_sync_mode = 0;
is_hotspot_vm = 0;
__collector_mutex_init (&jclasses_lock);
tsd_key = COLLECTOR_TSD_INVALID_KEY;
TprintfT (0, "jprofile: experiment closed.\n");
return 0;
}
static int
detach_experiment (void)
/* fork child. Clean up state but don't write to experiment */
{
__collector_java_mode = 0;
java_gc_on = 0;
jvm = NULL;
java_mem_mode = 0;
java_sync_mode = 0;
is_hotspot_vm = 0;
jvmti = NULL;
apistr = NULL;
__collector_mutex_init (&jclasses_lock);
tsd_key = COLLECTOR_TSD_INVALID_KEY;
TprintfT (0, "jprofile: detached from experiment.\n");
return 0;
}
JNIEXPORT jint JNICALL
JVM_OnLoad (JavaVM *vm, char *options, void *reserved)
{
jvmtiError err;
int use_jvmti = 0;
if (!__collector_java_mode)
{
TprintfT (DBG_LT1, "jprofile: JVM_OnLoad invoked with java mode disabled\n");
return JNI_OK;
}
else
TprintfT (DBG_LT1, "jprofile: JVM_OnLoad invoked\n");
jvm = vm;
jvmti = NULL;
if ((*jvm)->GetEnv (jvm, (void **) &jvmti, JVMTI_VERSION_1_0) >= 0 && jvmti)
{
TprintfT (DBG_LT1, "jprofile: JVMTI found\n");
use_jvmti = 1;
}
if (!use_jvmti)
{
collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\"/>\n",
SP_JCMD_CERROR, COL_ERROR_JVMNOTSUPP);
return JNI_ERR;
}
else
{
Tprintf (DBG_LT0, "\tjprofile: Initializing for JVMTI\n");
apistr = "JVMTI 1.0";
// setup JVMTI
jvmtiCapabilities cpblts;
err = (*jvmti)->GetPotentialCapabilities (jvmti, &cpblts);
if (err == JVMTI_ERROR_NONE)
{
jvmtiCapabilities cpblts_set;
CALL_UTIL (memset)(&cpblts_set, 0, sizeof (cpblts_set));
/* Add only those capabilities that are among potential ones */
cpblts_set.can_get_source_file_name = cpblts.can_get_source_file_name;
Tprintf (DBG_LT1, "\tjprofile: adding can_get_source_file_name capability: %u\n", cpblts.can_get_source_file_name);
cpblts_set.can_generate_compiled_method_load_events = cpblts.can_generate_compiled_method_load_events;
Tprintf (DBG_LT1, "\tjprofile: adding can_generate_compiled_method_load_events capability: %u\n", cpblts.can_generate_compiled_method_load_events);
if (java_sync_mode)
{
cpblts_set.can_generate_monitor_events = cpblts.can_generate_monitor_events;
Tprintf (DBG_LT1, "\tjprofile: adding can_generate_monitor_events capability: %u\n", cpblts.can_generate_monitor_events);
}
if (java_gc_on)
{
cpblts_set.can_generate_garbage_collection_events = cpblts.can_generate_garbage_collection_events;
Tprintf (DBG_LT1, "\tjprofile: adding can_generate_garbage_collection_events capability: %u\n", cpblts.can_generate_garbage_collection_events);
}
err = (*jvmti)->AddCapabilities (jvmti, &cpblts_set);
Tprintf (DBG_LT1, "\tjprofile: AddCapabilities() returns: %d\n", err);
}
err = (*jvmti)->SetEventCallbacks (jvmti, &callbacks, sizeof ( callbacks));
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_PREPARE, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_LOAD, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_COMPILED_METHOD_UNLOAD, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_DYNAMIC_CODE_GENERATED, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_THREAD_START, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_THREAD_END, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_FILE_LOAD_HOOK, NULL);
if (java_gc_on)
{
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_GARBAGE_COLLECTION_START, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_GARBAGE_COLLECTION_FINISH, NULL);
}
if (java_mem_mode)
{
// err = (*jvmti)->SetEventNotificationMode( jvmti, JVMTI_ENABLE, <no event for heap tracing> , NULL );
collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\"/>\n",
SP_JCMD_CWARN, COL_WARN_NO_JAVA_HEAP);
java_mem_mode = 0;
}
if (java_sync_mode)
{
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_MONITOR_CONTENDED_ENTER, NULL);
err = (*jvmti)->SetEventNotificationMode (jvmti, JVMTI_ENABLE, JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, NULL);
//err = (*jvmti)->SetEventNotificationMode( jvmti, JVMTI_ENABLE, JVMTI_EVENT_MONITOR_WAIT, NULL );
//err = (*jvmti)->SetEventNotificationMode( jvmti, JVMTI_ENABLE, JVMTI_EVENT_MONITOR_WAITED, NULL );
}
Tprintf (DBG_LT0, "\tjprofile: JVMTI initialized\n");
}
/* JVM still uses collector API on Solaris to notify us about dynamically generated code.
* If we ask it to generate events we'll end up with duplicate entries in the
* map file.
*/
if (use_jvmti)
{
err = (*jvmti)->GenerateEvents (jvmti, JVMTI_EVENT_DYNAMIC_CODE_GENERATED);
err = (*jvmti)->GenerateEvents (jvmti, JVMTI_EVENT_COMPILED_METHOD_LOAD);
}
Tprintf (DBG_LT1, "\tjprofile: JVM_OnLoad ok\n");
return JNI_OK;
}
/* This is currently just a placeholder */
JNIEXPORT jint JNICALL
Agent_OnLoad (JavaVM *vm, char *options, void *reserved)
{
return JVM_OnLoad (vm, options, reserved);
}
static void
rwrite (int fd, const void *buf, size_t nbyte)
{
size_t left = nbyte;
size_t res;
char *ptr = (char*) buf;
while (left > 0)
{
res = CALL_UTIL (write)(fd, ptr, left);
if (res == -1)
{
/* XXX: we can't write this record, we probably
* can't write anything else. Ignore.
*/
return;
}
left -= res;
ptr += res;
}
}
void
get_jvm_settings ()
{
jint res;
JNIEnv *jni;
jclass jcls;
jmethodID jmid;
jstring jstrin;
jstring jstrout;
const char *str;
res = (*jvm)->GetEnv (jvm, (void **) &jni, JNI_VERSION_1_2);
if (res < 0)
return;
/* I'm not checking if results are valid as JVM is extremely
* sensitive to exceptions that might occur during these JNI calls
* and will die with a fatal error later anyway.
*/
jcls = (*jni)->FindClass (jni, "java/lang/System");
jmid = (*jni)->GetStaticMethodID (jni, jcls, "getProperty", "(Ljava/lang/String;)Ljava/lang/String;");
jstrin = (*jni)->NewStringUTF (jni, "java.class.path");
jstrout = (*jni)->CallStaticObjectMethod (jni, jcls, jmid, jstrin);
str = jstrout ? (*jni)->GetStringUTFChars (jni, jstrout, NULL) : NULL;
if (str)
{
collector_interface->writeLog ("<setting %s=\"%s\"/>\n", SP_JCMD_SRCHPATH, str);
(*jni)->ReleaseStringUTFChars (jni, jstrout, str);
}
jstrin = (*jni)->NewStringUTF (jni, "sun.boot.class.path");
jstrout = (*jni)->CallStaticObjectMethod (jni, jcls, jmid, jstrin);
str = jstrout ? (*jni)->GetStringUTFChars (jni, jstrout, NULL) : NULL;
if (str)
{
collector_interface->writeLog ("<setting %s=\"%s\"/>\n", SP_JCMD_SRCHPATH, str);
(*jni)->ReleaseStringUTFChars (jni, jstrout, str);
}
jstrin = (*jni)->NewStringUTF (jni, "java.home");
jstrout = (*jni)->CallStaticObjectMethod (jni, jcls, jmid, jstrin);
str = jstrout ? (*jni)->GetStringUTFChars (jni, jstrout, NULL) : NULL;
if (str)
{
collector_interface->writeLog ("<setting %s=\"%s/../src.zip\"/>\n", SP_JCMD_SRCHPATH, str);
(*jni)->ReleaseStringUTFChars (jni, jstrout, str);
}
jstrin = (*jni)->NewStringUTF (jni, "java.vm.version");
jstrout = (*jni)->CallStaticObjectMethod (jni, jcls, jmid, jstrin);
str = jstrout ? (*jni)->GetStringUTFChars (jni, jstrout, NULL) : NULL;
if (str)
{
(void) collector_interface->writeLog ("<profile name=\"jprofile\" %s=\"%s\" %s=\"%s\"/>\n",
SP_JCMD_JVERSION, str, "api", apistr != NULL ? apistr : "N/A");
if (__collector_strStartWith (str, "1.4.2_02") < 0)
{
(void) collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\"/>\n",
SP_JCMD_CWARN, COL_WARN_OLDJAVA);
}
(*jni)->ReleaseStringUTFChars (jni, jstrout, str);
}
is_hotspot_vm = 0;
jstrin = (*jni)->NewStringUTF (jni, "sun.management.compiler");
jstrout = (*jni)->CallStaticObjectMethod (jni, jcls, jmid, jstrin);
str = jstrout ? (*jni)->GetStringUTFChars (jni, jstrout, NULL) : NULL;
if (str && __collector_strncmp (str, "HotSpot", 7) == 0)
is_hotspot_vm = 1;
/* Emulate System.setProperty( "collector.init", "true") */
jmid = (*jni)->GetStaticMethodID (jni, jcls, "setProperty",
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;");
jstrin = (*jni)->NewStringUTF (jni, "collector.init");
jstrout = (*jni)->NewStringUTF (jni, "true");
(*jni)->CallStaticObjectMethod (jni, jcls, jmid, jstrin, jstrout);
}
/*
* JVMTI code
*/
static void
jvmti_VMInit (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread)
{
jint class_count = 0;
jclass *classes = NULL;
int i;
TprintfT (DBG_LT1, "jprofile: jvmti_VMInit called\n");
get_jvm_settings ();
/* determine loaded classes */
(*jvmti_env)->GetLoadedClasses (jvmti_env, &class_count, &classes);
TprintfT (DBG_LT1, "jprofile: jvmti_VMInit initializing %d classes\n", class_count);
for (i = 0; i < class_count; i++)
{
// PushLocalFrame
jvmti_ClassPrepare (jvmti_env, jni_env, NULL, classes[i]);
// PopLocalFrame
// DeleteLocalRef( classes[i] );
}
(*jvmti_env)->Deallocate (jvmti_env, (unsigned char*) classes);
getResource = (*jni_env)->GetMethodID (jni_env, (*jni_env)->FindClass (jni_env, "java/lang/ClassLoader"), "getResource", "(Ljava/lang/String;)Ljava/net/URL;");
toExternalForm = (*jni_env)->GetMethodID (jni_env, (*jni_env)->FindClass (jni_env, "java/net/URL"), "toExternalForm", "()Ljava/lang/String;");
/* find the stack unwind routine */
jprof_find_asyncgetcalltrace ();
}
static void
jvmti_VMDeath (jvmtiEnv *jvmti_env, JNIEnv* jni_env)
{
__collector_java_mode = 0;
TprintfT (DBG_LT1, "jprofile: jvmti_VMDeath event received\n");
}
static void
jvmti_ThreadStart (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread)
{
jvmtiError err;
jvmtiThreadInfo t_info;
char *thread_name, *group_name, *parent_name;
hrtime_t hrt;
collector_thread_t tid;
thread_name = group_name = parent_name = NULL;
hrt = gethrtime ();
tid = __collector_thr_self ();
TprintfT (DBG_LT1, "jprofile: jvmti_ThreadStart: thread: %lu jni_env=%p jthread=%p\n",
(unsigned long) tid, jni_env, thread);
err = (*jvmti_env)->GetThreadInfo (jvmti_env, thread, &t_info);
if (err == JVMTI_ERROR_NONE)
{
jvmtiThreadGroupInfo g_info;
thread_name = t_info.name;
if (t_info.thread_group)
{
err = (*jvmti_env)->GetThreadGroupInfo (jvmti_env, t_info.thread_group, &g_info);
if (err == JVMTI_ERROR_NONE)
{
group_name = g_info.name;
if (g_info.parent)
{
jvmtiThreadGroupInfo p_info;
err = (*jvmti_env)->GetThreadGroupInfo (jvmti_env, g_info.parent, &p_info);
if (err == JVMTI_ERROR_NONE)
{
parent_name = p_info.name;
// DeleteLocalRef( p_info.parent );
}
// DeleteLocalRef( g_info.parent );
}
}
}
// DeleteLocalRef( t_info.thread_group );
// DeleteLocalRef( t_info.context_class_loader );
}
if (thread_name == NULL)
thread_name = "";
if (group_name == NULL)
group_name = "";
if (parent_name == NULL)
parent_name = "";
collector_interface->writeLog ("<event kind=\"%s\" tstamp=\"%u.%09u\" name=\"%s\" grpname=\"%s\" prntname=\"%s\" tid=\"%lu\" jthr=\"0x%lx\" jenv=\"0x%lx\"/>\n",
SP_JCMD_JTHRSTART,
(unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC),
thread_name,
group_name,
parent_name,
(unsigned long) tid,
thread,
jni_env
);
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd)
tsd->env = jni_env;
}
static void
jvmti_ThreadEnd (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread)
{
hrtime_t hrt = gethrtime ();
collector_thread_t tid = __collector_thr_self ();
TprintfT (DBG_LT1, "jprofile: jvmti_ThreadEnd: thread: %lu jni_env=%p jthread=%p\n",
(unsigned long) tid, jni_env, thread);
collector_interface->writeLog ("<event kind=\"%s\" tstamp=\"%u.%09u\" tid=\"%lu\" jthr=\"0x%lx\" jenv=\"0x%lx\"/>\n",
SP_JCMD_JTHREND,
(unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC),
(unsigned long) tid,
thread,
jni_env
);
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd)
tsd->env = NULL;
}
/* The following definitions are borrowed from file jvmticmlr.h, part of jdk7 */
typedef enum
{
JVMTI_CMLR_DUMMY = 1,
JVMTI_CMLR_INLINE_INFO = 2
} jvmtiCMLRKind;
/*
* Record that represents arbitrary information passed through JVMTI
* CompiledMethodLoadEvent void pointer.
*/
typedef struct _jvmtiCompiledMethodLoadRecordHeader
{
jvmtiCMLRKind kind; /* id for the kind of info passed in the record */
jint majorinfoversion; /* major and minor info version values. Init'ed */
jint minorinfoversion; /* to current version value in jvmtiExport.cpp. */
struct _jvmtiCompiledMethodLoadRecordHeader* next;
} jvmtiCompiledMethodLoadRecordHeader;
/*
* Record that gives information about the methods on the compile-time
* stack at a specific pc address of a compiled method. Each element in
* the methods array maps to same element in the bcis array.
*/
typedef struct _PCStackInfo
{
void* pc; /* the pc address for this compiled method */
jint numstackframes; /* number of methods on the stack */
jmethodID* methods; /* array of numstackframes method ids */
jint* bcis; /* array of numstackframes bytecode indices */
} PCStackInfo;
/*
* Record that contains inlining information for each pc address of
* an nmethod.
*/
typedef struct _jvmtiCompiledMethodLoadInlineRecord
{
jvmtiCompiledMethodLoadRecordHeader header; /* common header for casting */
jint numpcs; /* number of pc descriptors in this nmethod */
PCStackInfo* pcinfo; /* array of numpcs pc descriptors */
} jvmtiCompiledMethodLoadInlineRecord;
static void
jvmti_CompiledMethodLoad (jvmtiEnv *jvmti_env, jmethodID method,
jint code_size, const void *code_addr, jint map_length,
const jvmtiAddrLocationMap *map,
const void *compile_info)
{
TprintfT (DBG_LT2, "jprofile: jvmti_CompiledMethodLoad: mid=0x%lx addr=%p sz=0x%lu map=%p info=%p\n",
(unsigned long) method, code_addr, (long) code_size, map, compile_info);
char name[32];
CALL_UTIL (snprintf)(name, sizeof (name), "0x%lx", (unsigned long) method);
/* Parse compile_info to get pc -> bci mapping.
* Don't interpret compile_info from JVMs other than HotSpot.
*/
int lntsize = 0;
DT_lineno *lntable = NULL;
if (compile_info != NULL && is_hotspot_vm)
{
Tprintf (DBG_LT2, "Mapping from compile_info:\n");
jvmtiCompiledMethodLoadRecordHeader *currec =
(jvmtiCompiledMethodLoadRecordHeader*) compile_info;
while (currec != NULL)
{
if (currec->kind == JVMTI_CMLR_INLINE_INFO)
{
jvmtiCompiledMethodLoadInlineRecord *inrec =
(jvmtiCompiledMethodLoadInlineRecord*) currec;
if (inrec->numpcs <= 0)
break;
lntsize = inrec->numpcs;
lntable = (DT_lineno*) alloca (lntsize * sizeof (DT_lineno));
PCStackInfo *pcrec = inrec->pcinfo;
DT_lineno *lnorec = lntable;
for (int i = 0; i < lntsize; ++i)
{
for (int j = pcrec->numstackframes - 1; j >= 0; --j)
if (pcrec->methods[j] == method)
{
lnorec->offset = (char*) pcrec->pc - (char*) code_addr;
lnorec->lineno = pcrec->bcis[j];
Tprintf (DBG_LT2, " pc: 0x%lx bci: 0x%lx\n",
(long) lnorec->offset, (long) lnorec->lineno);
++lnorec;
break;
}
++pcrec;
}
break;
}
currec = currec->next;
}
}
else if (map != NULL)
{
Tprintf (DBG_LT2, "Mapping from jvmtiAddrLocationMap:\n");
lntsize = map_length;
lntable = (DT_lineno*) alloca (lntsize * sizeof (DT_lineno));
DT_lineno *lnorec = lntable;
for (int i = 0; i < map_length; ++i)
{
lnorec->offset = (char*) map[i].start_address - (char*) code_addr;
lnorec->lineno = (unsigned int) map[i].location;
Tprintf (DBG_LT2, " pc: 0x%lx bci: 0x%lx\n",
(long) lnorec->offset, (long) lnorec->lineno);
++lnorec;
}
}
__collector_int_func_load (DFUNC_JAVA, name, NULL, (void*) code_addr,
code_size, lntsize, lntable);
}
static void
jvmti_CompiledMethodUnload (jvmtiEnv *jvmti_env, jmethodID method, const void* code_addr)
{
__collector_int_func_unload (DFUNC_API, (void*) code_addr);
}
static void
jvmti_DynamicCodeGenerated (jvmtiEnv *jvmti_env, const char*name, const void *code_addr, jint code_size)
{
__collector_int_func_load (DFUNC_API, (char*) name, NULL, (void*) code_addr,
code_size, 0, NULL);
}
static void
addToDynamicArchive (const char* name, const unsigned char* class_data, int class_data_len)
{
char path[MAXPATHLEN + 1];
mode_t fmode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
mode_t dmode = fmode | S_IXUSR | S_IXGRP | S_IXOTH;
if (name == NULL)
name = "";
const char *expdir = collector_interface->getExpDir ();
if (CALL_UTIL (strlen)(expdir) +
CALL_UTIL (strlen)(SP_DYNAMIC_CLASSES) +
CALL_UTIL (strlen)(name) + 8 > sizeof (path))
return;
CALL_UTIL (snprintf)(path, sizeof (path), "%s/%s/%s.class", expdir, SP_DYNAMIC_CLASSES, name);
/* Create all path components step by step starting with SP_DYNAMIC_CLASSES */
char *str = path + CALL_UTIL (strlen)(expdir) + 1 + CALL_UTIL (strlen)(SP_DYNAMIC_CLASSES);
while (str)
{
*str = '\0';
if (CALL_UTIL (mkdir)(path, dmode) != 0)
{
/* Checking for EEXIST is not enough, access() is more reliable */
if (CALL_UTIL (access)(path, F_OK) != 0)
{
collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\" ec=\"%d\">%s</event>\n",
SP_JCMD_CERROR, COL_ERROR_MKDIR, errno, path);
return;
}
}
*str++ = '/';
str = CALL_UTIL (strchr)(str, '/');
}
int fd = CALL_UTIL (open)(path, O_WRONLY | O_CREAT | O_TRUNC, fmode);
if (fd < 0)
{
collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\" ec=\"%d\">%s</event>\n",
SP_JCMD_CERROR, COL_ERROR_OVWOPEN, errno, path);
return;
}
rwrite (fd, class_data, class_data_len);
CALL_UTIL (close)(fd);
}
static void
jvmti_ClassFileLoadHook (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jclass class_being_redefined,
jobject loader, const char* name, jobject protection_domain, jint class_data_len,
const unsigned char* class_data, jint* new_class_data_len, unsigned char** new_class_data)
{
jclass loaderlass;
int err;
jvmtiPhase phase_ptr;
char *cname = NULL;
(*jvmti_env)->GetPhase (jvmti_env, &phase_ptr);
/* skip non live phases */
if (phase_ptr != JVMTI_PHASE_LIVE)
return;
/* skip system class loaders */
if (!loader)
return;
loaderlass = (*jni_env)->GetObjectClass (jni_env, loader);
err = (*jvmti_env)->GetClassSignature (jvmti_env, loaderlass, &cname, NULL);
if (err != JVMTI_ERROR_NONE || !cname || *cname == (char) 0)
return;
/* skip classes loaded with AppClassLoader (java.class.path) */
if (__collector_strcmp (cname, "Lsun/misc/Launcher$AppClassLoader;") == 0)
return;
addToDynamicArchive (name, class_data, (int) class_data_len);
}
#define NO_CLASS_NAME "<noname>"
#define NO_SOURCE_FILE "<Unknown>"
static void
record_jclass (uint64_t class_id, hrtime_t hrt, const char *cname, const char *sname)
{
size_t clen = ARCH_STRLEN (cname);
size_t slen = ARCH_STRLEN (sname);
size_t sz = sizeof (ARCH_jclass) + clen + slen;
ARCH_jclass *jcls = (ARCH_jclass*) alloca (sz);
jcls->comm.tsize = sz;
jcls->comm.type = ARCH_JCLASS;
jcls->class_id = class_id;
jcls->tstamp = hrt;
char *str = (char*) (jcls + 1);
size_t i = CALL_UTIL (strlcpy)(str, cname, clen);
str += i;
while (i++ < clen)
*str++ = (char) 0; /* pad with 0's */
i = CALL_UTIL (strlcpy)(str, sname, slen);
str += i;
while (i++ < slen)
*str++ = (char) 0; /* pad with 0's */
collector_interface->writeDataPacket (jprof_hndl, (CM_Packet*) jcls);
}
static void
record_jmethod (uint64_t class_id, uint64_t method_id,
const char *mname, const char *msign)
{
size_t mnlen = mname ? ARCH_STRLEN (mname) : 0;
size_t mslen = msign ? ARCH_STRLEN (msign) : 0;
size_t sz = sizeof (ARCH_jmethod) + mnlen + mslen;
ARCH_jmethod *jmth = (ARCH_jmethod*) alloca (sz);
if (jmth == NULL)
{
TprintfT (DBG_LT1, "jprofile: record_jmethod ERROR: failed to alloca(%ld)\n", (long) sz);
return;
}
jmth->comm.tsize = sz;
jmth->comm.type = ARCH_JMETHOD;
jmth->class_id = class_id;
jmth->method_id = method_id;
char *str = (char*) (jmth + 1);
if (mname)
{
size_t i = CALL_UTIL (strlcpy)(str, mname, mnlen);
str += i;
while (i++ < mnlen)
*str++ = (char) 0; /* pad with 0's */
}
if (msign)
{
size_t i = CALL_UTIL (strlcpy)(str, msign, mslen);
str += i;
while (i++ < mslen)
*str++ = (char) 0; /* pad with 0's */
}
collector_interface->writeDataPacket (jprof_hndl, (CM_Packet*) jmth);
}
static void
jvmti_ClassPrepare (jvmtiEnv *jvmti_env, JNIEnv* jni_env,
jthread thread, jclass klass)
{
hrtime_t hrt;
jint mnum;
jmethodID *mptr;
char *cname, *sname;
char *str1 = NULL;
int err = (*jvmti_env)->GetClassSignature (jvmti_env, klass, &str1, NULL);
if (err != JVMTI_ERROR_NONE || str1 == NULL || *str1 == (char) 0)
cname = NO_CLASS_NAME;
else
cname = str1;
if (*cname != 'L')
{
DprintfT (SP_DUMP_JAVA | SP_DUMP_TIME, "jvmti_ClassPrepare: GetClassSignature failed. err=%d cname=%s\n", err, cname);
return;
}
char *str2 = NULL;
err = (*jvmti_env)->GetSourceFileName (jvmti_env, klass, &str2);
if (err != JVMTI_ERROR_NONE || str2 == NULL || *str2 == (char) 0)
sname = NO_SOURCE_FILE;
else
sname = str2;
DprintfT (SP_DUMP_JAVA | SP_DUMP_TIME, "jvmti_ClassPrepare: cname=%s sname=%s\n", STR (cname), STR (sname));
/* Lock the whole file */
__collector_mutex_lock (&jclasses_lock);
hrt = gethrtime ();
record_jclass ((unsigned long) klass, hrt, cname, sname);
(*jvmti_env)->Deallocate (jvmti_env, (unsigned char *) str1);
(*jvmti_env)->Deallocate (jvmti_env, (unsigned char *) str2);
err = (*jvmti_env)->GetClassMethods (jvmti_env, klass, &mnum, &mptr);
if (err == JVMTI_ERROR_NONE)
{
for (int i = 0; i < mnum; i++)
{
char *mname, *msign;
err = (*jvmti_env)->GetMethodName (jvmti_env, mptr[i], &mname, &msign, NULL);
if (err != JVMTI_ERROR_NONE)
continue;
record_jmethod ((unsigned long) klass, (unsigned long) mptr[i], mname, msign);
// DeleteLocalRef( mptr[i] );
}
(*jvmti_env)->Deallocate (jvmti_env, (unsigned char*) mptr);
}
/* Unlock the file */
__collector_mutex_unlock (&jclasses_lock);
}
/*
* The CLASS_LOAD event is enabled to enable AsyncGetCallTrace
*/
static void
jvmti_ClassLoad (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread, jclass klass)
{
char *cname;
char *str1 = NULL;
int err = (*jvmti_env)->GetClassSignature (jvmti_env, klass, &str1, NULL);
if (err != JVMTI_ERROR_NONE || str1 == NULL || *str1 == (char) 0)
cname = NO_CLASS_NAME;
else
cname = str1;
jstring str = NULL;
const char* resourceName;
jobject classLoader = NULL;
err = (*jvmti)->GetClassLoader (jvmti, klass, &classLoader);
DprintfT (SP_DUMP_JAVA | SP_DUMP_TIME, "jprofile: jvmti_ClassLoad err=%d cname=%s\n", err, STR (cname));
if (err == 0)
{
if (classLoader == NULL)
{
// bootstrap class loader
resourceName = "";
}
else
{
char* name = (char *) alloca ((CALL_UTIL (strlen)(str1) + 32) * sizeof (char));
CALL_UTIL (strlcpy)(name, str1 + 1, CALL_UTIL (strlen)(str1));
name[CALL_UTIL (strlen)(name) - 1] = '\0'; // remove the last ';'
char* p;
for (p = name; *p != '\0'; p++)
if (*p == '.')
*p = '/';
CALL_UTIL (strlcat)(name, ".class", CALL_UTIL (strlen)(name) + CALL_UTIL (strlen)(".class") + 1);
if (getResource == NULL || toExternalForm == NULL)
{
resourceName = "";
DprintfT (SP_DUMP_JAVA | SP_DUMP_TIME, "jvmti_ClassLoad: class %s failed to get path with method missing\n", STR (cname));
}
else
{
jobject url = (*jni_env)->CallObjectMethod (jni_env, classLoader, getResource, (*jni_env)->NewStringUTF (jni_env, name));
if (url == NULL)
{
resourceName = "";
DprintfT (SP_DUMP_JAVA | SP_DUMP_TIME, "jvmti_ClassLoad: class %s failed to get path\n", STR (cname));
}
else
{
str = (jstring) (*jni_env)->CallObjectMethod (jni_env, url, toExternalForm);
resourceName = (*jni_env)->GetStringUTFChars (jni_env, str, NULL);
DprintfT (SP_DUMP_JAVA | SP_DUMP_TIME, "jvmti_ClassLoad: ARCH_JCLASS_LOCATION(Ox%x) class_id=0x%lx className='%s' fileName '%s'\n",
(int) ARCH_JCLASS_LOCATION, (unsigned long) klass, STR (cname), STR (resourceName));
size_t clen = ARCH_STRLEN (cname);
size_t slen = ARCH_STRLEN (resourceName);
size_t sz = sizeof (ARCH_jclass) + clen + slen;
ARCH_jclass_location *jcls = (ARCH_jclass_location*) alloca (sz);
jcls->comm.tsize = sz;
jcls->comm.type = ARCH_JCLASS_LOCATION;
jcls->class_id = (unsigned long) klass;
char *str = (char*) (jcls + 1);
size_t i = CALL_UTIL (strlcpy)(str, cname, clen);
str += i;
while (i++ < clen)
{
*str++ = (char) 0; /* pad with 0's */
}
i = CALL_UTIL (strlcpy)(str, resourceName, slen);
str += i;
while (i++ < slen)
{
*str++ = (char) 0; /* pad with 0's */
}
/* Lock the whole file */
__collector_mutex_lock (&jclasses_lock);
collector_interface->writeDataPacket (jprof_hndl, (CM_Packet*) jcls);
/* Unlock the file */
__collector_mutex_unlock (&jclasses_lock);
}
}
}
}
}
static void
jvmti_MonitorEnter (jvmtiEnv *jvmti_env, JNIEnv* jni_env,
jthread thread, jobject object)
{
if (collector_jsync_begin)
collector_jsync_begin ();
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd == NULL)
return;
tsd->tstamp = gethrtime ();
}
static void
jvmti_MonitorEntered (jvmtiEnv *jvmti_env, JNIEnv* jni_env,
jthread thread, jobject object)
{
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd == NULL)
return;
if (collector_jsync_end)
collector_jsync_end (tsd->tstamp, object);
}
static void
jvmti_GarbageCollectionStart (jvmtiEnv *jvmti_env)
{
hrtime_t hrt = gethrtime ();
collector_interface->writeLog ("<event kind=\"%s\" tstamp=\"%u.%09u\"/>\n",
SP_JCMD_GCSTART,
(unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC)
);
TprintfT (DBG_LT1, "jprofile: jvmti_GarbageCollectionStart.\n");
}
static void
jvmti_GarbageCollectionFinish (jvmtiEnv *jvmti_env)
{
hrtime_t hrt = gethrtime ();
collector_interface->writeLog ("<event kind=\"%s\" tstamp=\"%u.%09u\"/>\n",
SP_JCMD_GCEND,
(unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC)
);
TprintfT (DBG_LT1, "jprofile: jvmti_GarbageCollectionFinish.\n");
}
#if 0
static void
jvmti_MonitorWait (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread,
jobject object, jlong timed_out)
{
if (collector_sync_begin)
collector_sync_begin ();
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd == NULL)
return;
tsd->tstamp = gethrtime ();
}
static void
jvmti_MonitorWaited (jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread,
jobject object, jboolean timed_out)
{
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd == NULL)
return;
if (collector_sync_end)
collector_sync_end (tsd->tstamp, object);
}
#endif
static void
jprof_find_asyncgetcalltrace ()
{
void *jvmhandle;
if (__collector_VM_ReadByteInstruction == NULL)
__collector_VM_ReadByteInstruction = (int(*)()) dlsym (RTLD_DEFAULT, "Async_VM_ReadByteInstruction");
/* look for stack unwind function using default path */
AsyncGetCallTrace = (void (*)(JVMPI_CallTrace*, jint, ucontext_t*))
dlsym (RTLD_DEFAULT, "AsyncGetCallTrace");
if (AsyncGetCallTrace != NULL)
{
__collector_java_asyncgetcalltrace_loaded = 1;
TprintfT (DBG_LT1, "jprofile: AsyncGetCallTrace found with RTLD_DEFAULT\n");
}
else
{
/* not found there, find libjvm.so, and ask again */
jvmhandle = dlopen ("libjvm.so", RTLD_LAZY | RTLD_NOLOAD);
if (jvmhandle != NULL)
{
AsyncGetCallTrace = (void (*)(JVMPI_CallTrace*, jint, ucontext_t*))
dlsym (jvmhandle, "AsyncGetCallTrace");
}
}
if (AsyncGetCallTrace == NULL)
{
/* we could not find it -- write collector error */
TprintfT (0, "jprofile: ERROR -- AsyncGetCallTrace not found in address space\n");
char *err = dlerror ();
collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">%s</event>\n",
SP_JCMD_CERROR, COL_ERROR_JVMNOJSTACK, err ? err : "");
__collector_java_mode = 0;
}
else
{
__collector_java_asyncgetcalltrace_loaded = 1;
TprintfT (DBG_LT1, "jprofile: AsyncGetCallTrace initialized in jprof_jvmpi_init_done_event\n");
}
}
int
__collector_ext_jstack_unwind (char *ptr, int sz, ucontext_t *uc)
{
if (AsyncGetCallTrace == NULL)
{
TprintfT (DBG_LT0, "jprofile: __collector_ext_jstack_unwind: AsyncGetCallTrace is NULL\n");
return 0;
}
TSD_Entry *tsd = collector_interface->getKey (tsd_key);
if (tsd == NULL)
{
TprintfT (DBG_LT3, "jprofile: __collector_ext_jstack_unwind: tsd is NULL\n");
return 0;
}
if (__collector_java_attach && tsd->env == NULL && jvmti != NULL && jvm != NULL)
{
TprintfT (DBG_LT3, "jprofile: __collector_ext_jstack_unwind: tsd->env is NULL under attach\n");
JNIEnv* jni_env = NULL;
(*jvm)->GetEnv (jvm, (void **) &jni_env, JNI_VERSION_1_2);
tsd->env = jni_env;
}
if (tsd->env == NULL)
{
TprintfT (DBG_LT3, "jprofile: __collector_ext_jstack_unwind: tsd->env is NULL\n");
return 0;
}
/* skip the Java stack whenever another signal handler is present */
if (uc->uc_link)
{
TprintfT (DBG_LT3, "jprofile: __collector_ext_jstack_unwind: uc->uc_link is non-NULL\n");
return 0;
}
/* we don't expect Java frames in signal handlers, so
* unroll the list of saved contexts to the topmost one
*/
while (uc->uc_link)
uc = uc->uc_link;
Java_info *jinfo = (Java_info*) ptr;
jinfo->kind = JAVA_INFO;
jinfo->hsize = sizeof (Java_info);
ptr += sizeof (Java_info);
sz -= sizeof (Java_info);
JVMPI_CallTrace jtrace;
jtrace.env_id = tsd->env;
jtrace.frames = (JVMPI_CallFrame*) ptr;
/* nframes is how many frames we have room for */
jint nframes = sz / sizeof (JVMPI_CallFrame);
#if WSIZE(64)
/* bug 6909545: garbage in 64-bit JAVA_INFO */
CALL_UTIL (memset)(jtrace.frames, 0, nframes * sizeof (JVMPI_CallFrame));
#endif
#if ARCH(SPARC)
// 21328946 JDK bug 8129933 causes <no java callstack recorded> on sparc-Linux
// convert from ucontext_t to sigcontext
struct sigcontext sctx;
sctx.sigc_regs.tpc = uc->uc_mcontext.mc_gregs[MC_PC];
__collector_memcpy (sctx.sigc_regs.u_regs, &uc->uc_mcontext.mc_gregs[3], sizeof (sctx.sigc_regs.u_regs));
uc = (ucontext_t *) (&sctx);
#endif /* SPARC */
AsyncGetCallTrace (&jtrace, nframes, uc);
if (jtrace.num_frames == nframes)
{
JVMPI_CallFrame *last = &jtrace.frames[nframes - 1];
last->method_id = (jmethodID) SP_TRUNC_STACK_MARKER;
last->lineno = 0;
}
/* nframes is how many frames we actually got */
nframes = jtrace.num_frames;
TprintfT (DBG_LT3, "jprofile: __collector_ext_jstack_unwind: AsyncGetCallTrace jtrace.numframes = %d\n", nframes);
if (nframes <= 0)
{
/* negative values are error codes */
TprintfT (0, "jprofile: __collector_ext_jstack_unwind: AsyncGetCallTrace returned error: jtrace.numframes = %d\n", nframes);
nframes = 1;
JVMPI_CallFrame *err = (JVMPI_CallFrame*) ptr;
err->lineno = jtrace.num_frames; // bci = error code
err->method_id = 0; // artificial method id
}
jinfo->hsize += nframes * sizeof (JVMPI_CallFrame);
return jinfo->hsize;
}
/*
* Collector Java API implementation
*/
void
Java_com_sun_forte_st_collector_CollectorAPI__1sample(JNIEnv *jEnv, jclass jCls, jstring jName)
{
JNIEnv *jni;
jint res = (*jvm)->GetEnv (jvm, (void **) &jni, JNI_VERSION_1_2);
if (res < 0)
return;
const char *name = jName ? (*jni)->GetStringUTFChars (jni, jName, NULL) : NULL;
__collector_sample ((char*) name);
}
void
Java_com_sun_forte_st_collector_CollectorAPI__1pause(JNIEnv *jEnv, jclass jCls)
{
__collector_pause_m ("JAPI");
}
void
Java_com_sun_forte_st_collector_CollectorAPI__1resume(JNIEnv *jEnv, jclass jCls)
{
__collector_resume ();
}
void
Java_com_sun_forte_st_collector_CollectorAPI__1terminate(JNIEnv *jEnv, jclass jCls)
{
__collector_terminate_expt ();
}
#endif /* GPROFNG_JAVA_PROFILING */
static void init_module () __attribute__ ((constructor));
static void
init_module ()
{
#if defined(GPROFNG_JAVA_PROFILING)
__collector_dlsym_guard = 1;
RegModuleFunc reg_module = (RegModuleFunc) dlsym (RTLD_DEFAULT, "__collector_register_module");
__collector_dlsym_guard = 0;
if (reg_module)
{
jprof_hndl = reg_module (&module_interface);
TprintfT (0, "jprofile: init_module.\n");
}
#endif /* GPROFNG_JAVA_PROFILING */
}
int __collector_java_mode = 0;
int __collector_java_asyncgetcalltrace_loaded = 0;
Reference in New Issue View Git Blame Copy Permalink