| /* |
| * Copyright 2002 Sun Microsystems, Inc. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| * |
| */ |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| #include <stdlib.h> |
| #include <vector> |
| #include "sa.hpp" |
| #include "jni.h" |
| #include "jvmdi.h" |
| |
| #ifndef WIN32 |
| #include <inttypes.h> |
| #else |
| typedef int int32_t; |
| #endif |
| |
| #ifdef WIN32 |
| #include <windows.h> |
| #define YIELD() Sleep(0) |
| #define SLEEP() Sleep(10) |
| #define vsnprintf _vsnprintf |
| #else |
| Error: please port YIELD() and SLEEP() macros to your platform |
| #endif |
| |
| using namespace std; |
| |
| ////////////////////////////////////////////////////////////////////// |
| // // |
| // Exported "interface" for Java language-level interaction between // |
| // the SA and the VM. Note that the SA knows about the layout of // |
| // certain VM data structures and that knowledge is taken advantage // |
| // of in this code, although this interfaces with the VM via JVMDI. // |
| // // |
| ////////////////////////////////////////////////////////////////////// |
| |
| extern "C" { |
| ///////////////////////////////////// |
| // // |
| // Events sent by the VM to the SA // |
| // // |
| ///////////////////////////////////// |
| |
| // Set by the SA when it attaches. Indicates that events should be |
| // posted via these exported variables, and that the VM should wait |
| // for those events to be acknowledged by the SA (via its setting |
| // saEventPending to 0). |
| JNIEXPORT volatile int32_t saAttached = 0; |
| |
| // Set to nonzero value by the VM when an event has been posted; set |
| // back to 0 by the SA when it has processed that event. |
| JNIEXPORT volatile int32_t saEventPending = 0; |
| |
| // Kind of the event (from jvmdi.h) |
| JNIEXPORT volatile int32_t saEventKind = 0; |
| |
| // |
| // Exception events |
| // |
| JNIEXPORT jthread saExceptionThread; |
| JNIEXPORT jclass saExceptionClass; |
| JNIEXPORT jmethodID saExceptionMethod; |
| JNIEXPORT int32_t saExceptionLocation; |
| JNIEXPORT jobject saExceptionException; |
| JNIEXPORT jclass saExceptionCatchClass; |
| JNIEXPORT jmethodID saExceptionCatchMethod; |
| JNIEXPORT int32_t saExceptionCatchLocation; |
| |
| // |
| // Breakpoint events |
| // |
| JNIEXPORT jthread saBreakpointThread; |
| JNIEXPORT jclass saBreakpointClass; |
| JNIEXPORT jmethodID saBreakpointMethod; |
| JNIEXPORT jlocation saBreakpointLocation; |
| |
| /////////////////////////////////////// |
| // // |
| // Commands sent by the SA to the VM // |
| // // |
| /////////////////////////////////////// |
| |
| extern JNIEXPORT const int32_t SA_CMD_SUSPEND_ALL = 0; |
| extern JNIEXPORT const int32_t SA_CMD_RESUME_ALL = 1; |
| extern JNIEXPORT const int32_t SA_CMD_TOGGLE_BREAKPOINT = 2; |
| extern JNIEXPORT const int32_t SA_CMD_BUF_SIZE = 1024; |
| |
| // SA sets this to a nonzero value when it is requesting a command |
| // to be processed; VM sets it back to 0 when the command has been |
| // executed |
| JNIEXPORT volatile int32_t saCmdPending = 0; |
| |
| // SA sets this to one of the manifest constants above to indicate |
| // the kind of command to be executed |
| JNIEXPORT volatile int32_t saCmdType = 0; |
| |
| // VM sets this to 0 if the last command succeeded or a nonzero |
| // value if it failed |
| JNIEXPORT volatile int32_t saCmdResult = 0; |
| |
| // If last command failed, this buffer will contain a descriptive |
| // error message |
| JNIEXPORT char saCmdResultErrMsg[SA_CMD_BUF_SIZE]; |
| |
| // |
| // Toggling of breakpoint command arguments. |
| // |
| // Originally there were separate set/clear breakpoint commands |
| // taking a class name, method name and signature, and the iteration |
| // through the debug information was done in the SA. It turns out |
| // that doing this work in the target VM is significantly faster, |
| // and since interactivity when setting and clearing breakpoints is |
| // important, the solution which resulted in more C/C++ code was used. |
| // |
| |
| // Source file name |
| JNIEXPORT char saCmdBkptSrcFileName[SA_CMD_BUF_SIZE]; |
| |
| // Package name ('/' as separator instead of '.') |
| JNIEXPORT char saCmdBkptPkgName[SA_CMD_BUF_SIZE]; |
| |
| // Line number |
| JNIEXPORT int32_t saCmdBkptLineNumber; |
| |
| // Output back to SA: indicator whether the last failure of a |
| // breakpoint toggle command was really an error or just a lack of |
| // debug information covering the requested line. 0 if not error. |
| // Valid only if saCmdResult != 0. |
| JNIEXPORT int32_t saCmdBkptResWasError; |
| |
| // Output back to SA: resulting line number at which the breakpoint |
| // was set or cleared (valid only if saCmdResult == 0) |
| JNIEXPORT int32_t saCmdBkptResLineNumber; |
| |
| // Output back to SA: resulting byte code index at which the |
| // breakpoint was set or cleared (valid only if saCmdResult == 0) |
| JNIEXPORT int32_t saCmdBkptResBCI; |
| |
| // Output back to SA: indicator whether the breakpoint operation |
| // resulted in a set or cleared breakpoint; nonzero if set, zero if |
| // cleared (valid only if saCmdResult == 0) |
| JNIEXPORT int32_t saCmdBkptResWasSet; |
| |
| // Output back to SA: method name the breakpoint was set in (valid |
| // only if saCmdResult == 0) |
| JNIEXPORT char saCmdBkptResMethodName[SA_CMD_BUF_SIZE]; |
| |
| // Output back to SA: method signature (JNI style) the breakpoint |
| // was set in (valid only if saCmdResult == 0) |
| JNIEXPORT char saCmdBkptResMethodSig[SA_CMD_BUF_SIZE]; |
| } |
| |
| // Internal state |
| static JavaVM* jvm = NULL; |
| static JVMDI_Interface_1* jvmdi = NULL; |
| static jthread debugThreadObj = NULL; |
| static bool suspended = false; |
| static vector<jthread> suspendedThreads; |
| static JVMDI_RawMonitor eventLock = NULL; |
| |
| class MonitorLocker { |
| private: |
| JVMDI_RawMonitor lock; |
| public: |
| MonitorLocker(JVMDI_RawMonitor lock) { |
| this->lock = lock; |
| if (lock != NULL) { |
| jvmdi->RawMonitorEnter(lock); |
| } |
| } |
| ~MonitorLocker() { |
| if (lock != NULL) { |
| jvmdi->RawMonitorExit(lock); |
| } |
| } |
| }; |
| |
| class JvmdiDeallocator { |
| private: |
| void* ptr; |
| public: |
| JvmdiDeallocator(void* ptr) { |
| this->ptr = ptr; |
| } |
| ~JvmdiDeallocator() { |
| jvmdi->Deallocate((jbyte*) ptr); |
| } |
| }; |
| |
| class JvmdiRefListDeallocator { |
| private: |
| JNIEnv* env; |
| jobject* refList; |
| jint refCount; |
| public: |
| JvmdiRefListDeallocator(JNIEnv* env, jobject* refList, jint refCount) { |
| this->env = env; |
| this->refList = refList; |
| this->refCount = refCount; |
| } |
| ~JvmdiRefListDeallocator() { |
| for (int i = 0; i < refCount; i++) { |
| env->DeleteGlobalRef(refList[i]); |
| } |
| jvmdi->Deallocate((jbyte*) refList); |
| } |
| }; |
| |
| static void |
| stop(char* msg) { |
| fprintf(stderr, "%s", msg); |
| fprintf(stderr, "\n"); |
| exit(1); |
| } |
| |
| // This fills in the command result error message, sets the command |
| // result to -1, and clears the pending command flag |
| static void |
| reportErrorToSA(const char* str, ...) { |
| va_list varargs; |
| va_start(varargs, str); |
| vsnprintf(saCmdResultErrMsg, sizeof(saCmdResultErrMsg), str, varargs); |
| va_end(varargs); |
| saCmdResult = -1; |
| saCmdPending = 0; |
| } |
| |
| static bool |
| packageNameMatches(char* clazzName, char* pkg) { |
| int pkgLen = strlen(pkg); |
| int clazzNameLen = strlen(clazzName); |
| |
| if (pkgLen >= clazzNameLen + 1) { |
| return false; |
| } |
| |
| if (strncmp(clazzName, pkg, pkgLen)) { |
| return false; |
| } |
| |
| // Ensure that '/' is the next character if non-empty package name |
| int l = pkgLen; |
| if (l > 0) { |
| if (clazzName[l] != '/') { |
| return false; |
| } |
| l++; |
| } |
| // Ensure that there are no more trailing slashes |
| while (l < clazzNameLen) { |
| if (clazzName[l++] == '/') { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static void |
| executeOneCommand(JNIEnv* env) { |
| switch (saCmdType) { |
| case SA_CMD_SUSPEND_ALL: { |
| if (suspended) { |
| reportErrorToSA("Target process already suspended"); |
| return; |
| } |
| |
| // We implement this by getting all of the threads and calling |
| // SuspendThread on each one, except for the thread object |
| // corresponding to this thread. Each thread for which the call |
| // succeeded (i.e., did not return JVMDI_ERROR_INVALID_THREAD) |
| // is added to a list which is remembered for later resumption. |
| // Note that this currently has race conditions since a thread |
| // might be started after we call GetAllThreads and since a |
| // thread for which we got an error earlier might be resumed by |
| // the VM while we are busy suspending other threads. We could |
| // solve this by looping until there are no more threads we can |
| // suspend, but a more robust and scalable solution is to add |
| // this functionality to the JVMDI interface (i.e., |
| // "suspendAll"). Probably need to provide an exclude list for |
| // such a routine. |
| jint threadCount; |
| jthread* threads; |
| if (jvmdi->GetAllThreads(&threadCount, &threads) != JVMDI_ERROR_NONE) { |
| reportErrorToSA("Error while getting thread list"); |
| return; |
| } |
| |
| |
| for (int i = 0; i < threadCount; i++) { |
| jthread thr = threads[i]; |
| if (!env->IsSameObject(thr, debugThreadObj)) { |
| jvmdiError err = jvmdi->SuspendThread(thr); |
| if (err == JVMDI_ERROR_NONE) { |
| // Remember this thread and do not free it |
| suspendedThreads.push_back(thr); |
| continue; |
| } else { |
| fprintf(stderr, " SA: Error %d while suspending thread\n", err); |
| // FIXME: stop, resume all threads, report error |
| } |
| } |
| env->DeleteGlobalRef(thr); |
| } |
| |
| // Free up threads |
| jvmdi->Deallocate((jbyte*) threads); |
| |
| // Suspension is complete |
| suspended = true; |
| break; |
| } |
| |
| case SA_CMD_RESUME_ALL: { |
| if (!suspended) { |
| reportErrorToSA("Target process already suspended"); |
| return; |
| } |
| |
| saCmdResult = 0; |
| bool errorOccurred = false; |
| jvmdiError firstError; |
| for (int i = 0; i < suspendedThreads.size(); i++) { |
| jthread thr = suspendedThreads[i]; |
| jvmdiError err = jvmdi->ResumeThread(thr); |
| env->DeleteGlobalRef(thr); |
| if (err != JVMDI_ERROR_NONE) { |
| if (!errorOccurred) { |
| errorOccurred = true; |
| firstError = err; |
| } |
| } |
| } |
| suspendedThreads.clear(); |
| suspended = false; |
| if (errorOccurred) { |
| reportErrorToSA("Error %d while resuming threads", firstError); |
| return; |
| } |
| break; |
| } |
| |
| case SA_CMD_TOGGLE_BREAKPOINT: { |
| saCmdBkptResWasError = 1; |
| |
| // Search line number info for all loaded classes |
| jint classCount; |
| jclass* classes; |
| |
| jvmdiError glcRes = jvmdi->GetLoadedClasses(&classCount, &classes); |
| if (glcRes != JVMDI_ERROR_NONE) { |
| reportErrorToSA("Error %d while getting loaded classes", glcRes); |
| return; |
| } |
| JvmdiRefListDeallocator rld(env, (jobject*) classes, classCount); |
| |
| bool done = false; |
| bool gotOne = false; |
| jclass targetClass; |
| jmethodID targetMethod; |
| jlocation targetLocation; |
| jint targetLineNumber; |
| |
| for (int i = 0; i < classCount && !done; i++) { |
| fflush(stderr); |
| jclass clazz = classes[i]; |
| char* srcName; |
| jvmdiError sfnRes = jvmdi->GetSourceFileName(clazz, &srcName); |
| if (sfnRes == JVMDI_ERROR_NONE) { |
| JvmdiDeallocator de1(srcName); |
| if (!strcmp(srcName, saCmdBkptSrcFileName)) { |
| // Got a match. Now see whether the package name of the class also matches |
| char* clazzName; |
| jvmdiError sigRes = jvmdi->GetClassSignature(clazz, &clazzName); |
| if (sigRes != JVMDI_ERROR_NONE) { |
| reportErrorToSA("Error %d while getting a class's signature", sigRes); |
| return; |
| } |
| JvmdiDeallocator de2(clazzName); |
| if (packageNameMatches(clazzName + 1, saCmdBkptPkgName)) { |
| // Iterate through all methods |
| jint methodCount; |
| jmethodID* methods; |
| if (jvmdi->GetClassMethods(clazz, &methodCount, &methods) != JVMDI_ERROR_NONE) { |
| reportErrorToSA("Error while getting methods of class %s", clazzName); |
| return; |
| } |
| JvmdiDeallocator de3(methods); |
| for (int j = 0; j < methodCount && !done; j++) { |
| jmethodID m = methods[j]; |
| jint entryCount; |
| JVMDI_line_number_entry* table; |
| jvmdiError lnRes = jvmdi->GetLineNumberTable(clazz, m, &entryCount, &table); |
| if (lnRes == JVMDI_ERROR_NONE) { |
| JvmdiDeallocator de4(table); |
| // Look for line number greater than or equal to requested line |
| for (int k = 0; k < entryCount && !done; k++) { |
| JVMDI_line_number_entry& entry = table[k]; |
| if (entry.line_number >= saCmdBkptLineNumber && |
| (!gotOne || entry.line_number < targetLineNumber)) { |
| gotOne = true; |
| targetClass = clazz; |
| targetMethod = m; |
| targetLocation = entry.start_location; |
| targetLineNumber = entry.line_number; |
| done = (targetLineNumber == saCmdBkptLineNumber); |
| } |
| } |
| } else if (lnRes != JVMDI_ERROR_ABSENT_INFORMATION) { |
| reportErrorToSA("Unexpected error %d while fetching line number table", lnRes); |
| return; |
| } |
| } |
| } |
| } |
| } else if (sfnRes != JVMDI_ERROR_ABSENT_INFORMATION) { |
| reportErrorToSA("Unexpected error %d while fetching source file name", sfnRes); |
| return; |
| } |
| } |
| |
| bool wasSet = true; |
| if (gotOne) { |
| // Really toggle this breakpoint |
| jvmdiError bpRes; |
| bpRes = jvmdi->SetBreakpoint(targetClass, targetMethod, targetLocation); |
| if (bpRes == JVMDI_ERROR_DUPLICATE) { |
| bpRes = jvmdi->ClearBreakpoint(targetClass, targetMethod, targetLocation); |
| wasSet = false; |
| } |
| if (bpRes != JVMDI_ERROR_NONE) { |
| reportErrorToSA("Unexpected error %d while setting or clearing breakpoint at bci %d, line %d", |
| bpRes, targetLocation, targetLineNumber); |
| return; |
| } |
| } else { |
| saCmdBkptResWasError = 0; |
| reportErrorToSA("No debug information found covering this line"); |
| return; |
| } |
| |
| // Provide result |
| saCmdBkptResLineNumber = targetLineNumber; |
| saCmdBkptResBCI = targetLocation; |
| saCmdBkptResWasSet = (wasSet ? 1 : 0); |
| { |
| char* methodName; |
| char* methodSig; |
| if (jvmdi->GetMethodName(targetClass, targetMethod, &methodName, &methodSig) |
| == JVMDI_ERROR_NONE) { |
| JvmdiDeallocator mnd(methodName); |
| JvmdiDeallocator msd(methodSig); |
| strncpy(saCmdBkptResMethodName, methodName, SA_CMD_BUF_SIZE); |
| strncpy(saCmdBkptResMethodSig, methodSig, SA_CMD_BUF_SIZE); |
| } else { |
| strncpy(saCmdBkptResMethodName, "<error>", SA_CMD_BUF_SIZE); |
| strncpy(saCmdBkptResMethodSig, "<error>", SA_CMD_BUF_SIZE); |
| } |
| } |
| break; |
| } |
| |
| default: |
| reportErrorToSA("Command %d not yet supported", saCmdType); |
| return; |
| } |
| |
| // Successful command execution |
| saCmdResult = 0; |
| saCmdPending = 0; |
| } |
| |
| static void |
| saCommandThread(void *arg) { |
| JNIEnv* env = NULL; |
| if (jvm->GetEnv((void **) &env, JNI_VERSION_1_2) != JNI_OK) { |
| stop("Error while starting Serviceability Agent " |
| "command thread: could not get JNI environment"); |
| } |
| |
| while (1) { |
| // Wait for command |
| while (!saCmdPending) { |
| SLEEP(); |
| } |
| |
| executeOneCommand(env); |
| } |
| } |
| |
| static void |
| saEventHook(JNIEnv *env, JVMDI_Event *event) |
| { |
| MonitorLocker ml(eventLock); |
| |
| saEventKind = event->kind; |
| |
| if (event->kind == JVMDI_EVENT_VM_INIT) { |
| // Create event lock |
| if (jvmdi->CreateRawMonitor("Serviceability Agent Event Lock", &eventLock) |
| != JVMDI_ERROR_NONE) { |
| stop("Unable to create Serviceability Agent's event lock"); |
| } |
| // Start thread which receives commands from the SA. |
| jclass threadClass = env->FindClass("java/lang/Thread"); |
| if (threadClass == NULL) stop("Unable to find class java/lang/Thread"); |
| jstring threadName = env->NewStringUTF("Serviceability Agent Command Thread"); |
| if (threadName == NULL) stop("Unable to allocate debug thread name"); |
| jmethodID ctor = env->GetMethodID(threadClass, "<init>", "(Ljava/lang/String;)V"); |
| if (ctor == NULL) stop("Unable to find appropriate constructor for java/lang/Thread"); |
| // Allocate thread object |
| jthread thr = (jthread) env->NewObject(threadClass, ctor, threadName); |
| if (thr == NULL) stop("Unable to allocate debug thread's java/lang/Thread instance"); |
| // Remember which thread this is |
| debugThreadObj = env->NewGlobalRef(thr); |
| if (debugThreadObj == NULL) stop("Unable to allocate global ref for debug thread object"); |
| // Start thread |
| jvmdiError err; |
| if ((err = jvmdi->RunDebugThread(thr, &saCommandThread, NULL, JVMDI_THREAD_NORM_PRIORITY)) |
| != JVMDI_ERROR_NONE) { |
| char buf[256]; |
| sprintf(buf, "Error %d while starting debug thread", err); |
| stop(buf); |
| } |
| // OK, initialization is done |
| return; |
| } |
| |
| if (!saAttached) { |
| return; |
| } |
| |
| switch (event->kind) { |
| case JVMDI_EVENT_EXCEPTION: { |
| fprintf(stderr, "SA: Exception thrown -- ignoring\n"); |
| saExceptionThread = event->u.exception.thread; |
| saExceptionClass = event->u.exception.clazz; |
| saExceptionMethod = event->u.exception.method; |
| saExceptionLocation = event->u.exception.location; |
| saExceptionException = event->u.exception.exception; |
| saExceptionCatchClass = event->u.exception.catch_clazz; |
| saExceptionCatchClass = event->u.exception.catch_clazz; |
| saExceptionCatchMethod = event->u.exception.catch_method; |
| saExceptionCatchLocation = event->u.exception.catch_location; |
| // saEventPending = 1; |
| break; |
| } |
| |
| case JVMDI_EVENT_BREAKPOINT: { |
| saBreakpointThread = event->u.breakpoint.thread; |
| saBreakpointClass = event->u.breakpoint.clazz; |
| saBreakpointMethod = event->u.breakpoint.method; |
| saBreakpointLocation = event->u.breakpoint.location; |
| saEventPending = 1; |
| break; |
| } |
| |
| default: |
| break; |
| } |
| |
| while (saAttached && saEventPending) { |
| SLEEP(); |
| } |
| } |
| |
| extern "C" { |
| JNIEXPORT jint JNICALL |
| JVM_OnLoad(JavaVM *vm, char *options, void *reserved) |
| { |
| jvm = vm; |
| if (jvm->GetEnv((void**) &jvmdi, JVMDI_VERSION_1) != JNI_OK) { |
| return -1; |
| } |
| if (jvmdi->SetEventHook(&saEventHook) != JVMDI_ERROR_NONE) { |
| return -1; |
| } |
| return 0; |
| } |
| }; |
