Mercurial > hg > truffle
view agent/src/share/native/jvmdi/sa.cpp @ 1934:b1f2e875300a
Small fix to make Graal snippets work with bounds check elimination.
author | Thomas Wuerthinger <wuerthinger@ssw.jku.at> |
---|---|
date | Tue, 21 Dec 2010 17:40:10 +0100 |
parents | c18cbe5936b8 |
children |
line wrap: on
line source
/* * Copyright (c) 2002, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.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; } };