| /* |
| * Copyright (c) 1998, 2012, 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. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * 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 <ctype.h> |
| |
| #include "util.h" |
| #include "commonRef.h" |
| #include "debugDispatch.h" |
| #include "eventHandler.h" |
| #include "eventHelper.h" |
| #include "threadControl.h" |
| #include "stepControl.h" |
| #include "transport.h" |
| #include "classTrack.h" |
| #include "debugLoop.h" |
| #include "bag.h" |
| #include "invoker.h" |
| #include "sys.h" |
| |
| /* How the options get to OnLoad: */ |
| #define XDEBUG "-Xdebug" |
| #define XRUN "-Xrunjdwp" |
| #define AGENTLIB "-agentlib:jdwp" |
| |
| /* Debug version defaults */ |
| #ifdef DEBUG |
| #define DEFAULT_ASSERT_ON JNI_TRUE |
| #define DEFAULT_ASSERT_FATAL JNI_TRUE |
| #define DEFAULT_LOGFILE "jdwp.log" |
| #else |
| #define DEFAULT_ASSERT_ON JNI_FALSE |
| #define DEFAULT_ASSERT_FATAL JNI_FALSE |
| #define DEFAULT_LOGFILE NULL |
| #endif |
| |
| static jboolean vmInitialized; |
| static jrawMonitorID initMonitor; |
| static jboolean initComplete; |
| static jbyte currentSessionID; |
| |
| /* |
| * Options set through the OnLoad options string. All of these values |
| * are set once at VM startup and never reset. |
| */ |
| static jboolean isServer = JNI_FALSE; /* Listens for connecting debuggers? */ |
| static jboolean isStrict = JNI_FALSE; /* Unused */ |
| static jboolean useStandardAlloc = JNI_FALSE; /* Use standard malloc/free? */ |
| static struct bag *transports; /* of TransportSpec */ |
| |
| static jboolean initOnStartup = JNI_TRUE; /* init immediately */ |
| static char *initOnException = NULL; /* init when this exception thrown */ |
| static jboolean initOnUncaught = JNI_FALSE; /* init when uncaught exc thrown */ |
| |
| static char *launchOnInit = NULL; /* launch this app during init */ |
| static jboolean suspendOnInit = JNI_TRUE; /* suspend all app threads after init */ |
| static jboolean dopause = JNI_FALSE; /* pause for debugger attach */ |
| static jboolean docoredump = JNI_FALSE; /* core dump on exit */ |
| static char *logfile = NULL; /* Name of logfile (if logging) */ |
| static unsigned logflags = 0; /* Log flags */ |
| |
| static char *names; /* strings derived from OnLoad options */ |
| |
| /* |
| * Elements of the transports bag |
| */ |
| typedef struct TransportSpec { |
| char *name; |
| char *address; |
| long timeout; |
| } TransportSpec; |
| |
| /* |
| * Forward Refs |
| */ |
| static void JNICALL cbEarlyVMInit(jvmtiEnv*, JNIEnv *, jthread); |
| static void JNICALL cbEarlyVMDeath(jvmtiEnv*, JNIEnv *); |
| static void JNICALL cbEarlyException(jvmtiEnv*, JNIEnv *, |
| jthread, jmethodID, jlocation, jobject, jmethodID, jlocation); |
| |
| static void initialize(JNIEnv *env, jthread thread, EventIndex triggering_ei); |
| static jboolean parseOptions(char *str); |
| |
| /* |
| * Phase 1: Initial load. |
| * |
| * OnLoad is called by the VM immediately after the back-end |
| * library is loaded. We can do very little in this function since |
| * the VM has not completed initialization. So, we parse the JDWP |
| * options and set up a simple initial event callbacks for JVMTI events. |
| * When a triggering event occurs, that callback will begin debugger initialization. |
| */ |
| |
| /* Get a static area to hold the Global Data */ |
| static BackendGlobalData * |
| get_gdata(void) |
| { |
| static BackendGlobalData s; |
| (void)memset(&s, 0, sizeof(BackendGlobalData)); |
| return &s; |
| } |
| |
| static jvmtiError |
| set_event_notification(jvmtiEventMode mode, EventIndex ei) |
| { |
| jvmtiError error; |
| error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode) |
| (gdata->jvmti, mode, eventIndex2jvmti(ei), NULL); |
| if (error != JVMTI_ERROR_NONE) { |
| ERROR_MESSAGE(("JDWP unable to configure initial JVMTI event %s: %s(%d)", |
| eventText(ei), jvmtiErrorText(error), error)); |
| } |
| return error; |
| } |
| |
| typedef struct { |
| int major; |
| int minor; |
| } version_type; |
| |
| typedef struct { |
| version_type runtime; |
| version_type compiletime; |
| } compatible_versions_type; |
| |
| /* |
| * List of explicitly compatible JVMTI versions, specified as |
| * { runtime version, compile-time version } pairs. -1 is a wildcard. |
| */ |
| static int nof_compatible_versions = 3; |
| static compatible_versions_type compatible_versions_list[] = { |
| /* |
| * FIXUP: Allow version 0 to be compatible with anything |
| * Special check for FCS of 1.0. |
| */ |
| { { 0, -1 }, { -1, -1 } }, |
| { { -1, -1 }, { 0, -1 } }, |
| /* |
| * 1.2 is runtime compatible with 1.1 -- just make sure to check the |
| * version before using any new 1.2 features |
| */ |
| { { 1, 1 }, { 1, 2 } } |
| }; |
| |
| |
| /* Logic to determine JVMTI version compatibility */ |
| static jboolean |
| compatible_versions(jint major_runtime, jint minor_runtime, |
| jint major_compiletime, jint minor_compiletime) |
| { |
| /* |
| * First check to see if versions are explicitly compatible via the |
| * list specified above. |
| */ |
| int i; |
| for (i = 0; i < nof_compatible_versions; ++i) { |
| version_type runtime = compatible_versions_list[i].runtime; |
| version_type comptime = compatible_versions_list[i].compiletime; |
| |
| if ((major_runtime == runtime.major || runtime.major == -1) && |
| (minor_runtime == runtime.minor || runtime.minor == -1) && |
| (major_compiletime == comptime.major || comptime.major == -1) && |
| (minor_compiletime == comptime.minor || comptime.minor == -1)) { |
| return JNI_TRUE; |
| } |
| } |
| |
| return major_runtime == major_compiletime && |
| minor_runtime >= minor_compiletime; |
| } |
| |
| /* OnLoad startup: |
| * Returning JNI_ERR will cause the java_g VM to core dump, be careful. |
| */ |
| JNIEXPORT jint JNICALL |
| Agent_OnLoad(JavaVM *vm, char *options, void *reserved) |
| { |
| jvmtiError error; |
| jvmtiCapabilities needed_capabilities; |
| jvmtiCapabilities potential_capabilities; |
| jint jvmtiCompileTimeMajorVersion; |
| jint jvmtiCompileTimeMinorVersion; |
| jint jvmtiCompileTimeMicroVersion; |
| char *boot_path = NULL; |
| char npt_lib[MAXPATHLEN]; |
| |
| /* See if it's already loaded */ |
| if ( gdata!=NULL && gdata->isLoaded==JNI_TRUE ) { |
| ERROR_MESSAGE(("Cannot load this JVM TI agent twice, check your java command line for duplicate jdwp options.")); |
| return JNI_ERR; |
| } |
| |
| /* If gdata is defined and the VM died, why are we here? */ |
| if ( gdata!=NULL && gdata->vmDead ) { |
| ERROR_MESSAGE(("JDWP unable to load, VM died")); |
| return JNI_ERR; |
| } |
| |
| /* Get global data area */ |
| gdata = get_gdata(); |
| if (gdata == NULL) { |
| ERROR_MESSAGE(("JDWP unable to allocate memory")); |
| return JNI_ERR; |
| } |
| gdata->isLoaded = JNI_TRUE; |
| |
| /* Start filling in gdata */ |
| gdata->jvm = vm; |
| vmInitialized = JNI_FALSE; |
| gdata->vmDead = JNI_FALSE; |
| |
| /* Get the JVMTI Env, IMPORTANT: Do this first! For jvmtiAllocate(). */ |
| error = JVM_FUNC_PTR(vm,GetEnv) |
| (vm, (void **)&(gdata->jvmti), JVMTI_VERSION_1); |
| if (error != JNI_OK) { |
| ERROR_MESSAGE(("JDWP unable to access JVMTI Version 1 (0x%x)," |
| " is your J2SE a 1.5 or newer version?" |
| " JNIEnv's GetEnv() returned %d", |
| JVMTI_VERSION_1, error)); |
| forceExit(1); /* Kill entire process, no core dump */ |
| } |
| |
| /* Check to make sure the version of jvmti.h we compiled with |
| * matches the runtime version we are using. |
| */ |
| jvmtiCompileTimeMajorVersion = ( JVMTI_VERSION & JVMTI_VERSION_MASK_MAJOR ) |
| >> JVMTI_VERSION_SHIFT_MAJOR; |
| jvmtiCompileTimeMinorVersion = ( JVMTI_VERSION & JVMTI_VERSION_MASK_MINOR ) |
| >> JVMTI_VERSION_SHIFT_MINOR; |
| jvmtiCompileTimeMicroVersion = ( JVMTI_VERSION & JVMTI_VERSION_MASK_MICRO ) |
| >> JVMTI_VERSION_SHIFT_MICRO; |
| |
| /* Check for compatibility */ |
| if ( !compatible_versions(jvmtiMajorVersion(), jvmtiMinorVersion(), |
| jvmtiCompileTimeMajorVersion, jvmtiCompileTimeMinorVersion) ) { |
| |
| ERROR_MESSAGE(("This jdwp native library will not work with this VM's " |
| "version of JVMTI (%d.%d.%d), it needs JVMTI %d.%d[.%d].", |
| jvmtiMajorVersion(), |
| jvmtiMinorVersion(), |
| jvmtiMicroVersion(), |
| jvmtiCompileTimeMajorVersion, |
| jvmtiCompileTimeMinorVersion, |
| jvmtiCompileTimeMicroVersion)); |
| |
| /* Do not let VM get a fatal error, we don't want a core dump here. */ |
| forceExit(1); /* Kill entire process, no core dump wanted */ |
| } |
| |
| JVMTI_FUNC_PTR(gdata->jvmti, GetSystemProperty) |
| (gdata->jvmti, (const char *)"sun.boot.library.path", |
| &boot_path); |
| |
| dbgsysBuildLibName(npt_lib, sizeof(npt_lib), boot_path, NPT_LIBNAME); |
| /* Npt and Utf function init */ |
| NPT_INITIALIZE(npt_lib, &(gdata->npt), NPT_VERSION, NULL); |
| jvmtiDeallocate(boot_path); |
| if (gdata->npt == NULL) { |
| ERROR_MESSAGE(("JDWP: unable to initialize NPT library")); |
| return JNI_ERR; |
| } |
| gdata->npt->utf = (gdata->npt->utfInitialize)(NULL); |
| if (gdata->npt->utf == NULL) { |
| ERROR_MESSAGE(("JDWP: UTF function initialization failed")); |
| return JNI_ERR; |
| } |
| |
| /* Parse input options */ |
| if (!parseOptions(options)) { |
| /* No message necessary, should have been printed out already */ |
| /* Do not let VM get a fatal error, we don't want a core dump here. */ |
| forceExit(1); /* Kill entire process, no core dump wanted */ |
| } |
| |
| LOG_MISC(("Onload: %s", options)); |
| |
| /* Get potential capabilities */ |
| (void)memset(&potential_capabilities,0,sizeof(potential_capabilities)); |
| error = JVMTI_FUNC_PTR(gdata->jvmti,GetPotentialCapabilities) |
| (gdata->jvmti, &potential_capabilities); |
| if (error != JVMTI_ERROR_NONE) { |
| ERROR_MESSAGE(("JDWP unable to get potential JVMTI capabilities: %s(%d)", |
| jvmtiErrorText(error), error)); |
| return JNI_ERR; |
| } |
| |
| /* Fill in ones that we must have */ |
| (void)memset(&needed_capabilities,0,sizeof(needed_capabilities)); |
| needed_capabilities.can_access_local_variables = 1; |
| needed_capabilities.can_generate_single_step_events = 1; |
| needed_capabilities.can_generate_exception_events = 1; |
| needed_capabilities.can_generate_frame_pop_events = 1; |
| needed_capabilities.can_generate_breakpoint_events = 1; |
| needed_capabilities.can_suspend = 1; |
| needed_capabilities.can_generate_method_entry_events = 1; |
| needed_capabilities.can_generate_method_exit_events = 1; |
| needed_capabilities.can_generate_garbage_collection_events = 1; |
| needed_capabilities.can_maintain_original_method_order = 1; |
| needed_capabilities.can_generate_monitor_events = 1; |
| needed_capabilities.can_tag_objects = 1; |
| |
| /* And what potential ones that would be nice to have */ |
| needed_capabilities.can_force_early_return |
| = potential_capabilities.can_force_early_return; |
| needed_capabilities.can_generate_field_modification_events |
| = potential_capabilities.can_generate_field_modification_events; |
| needed_capabilities.can_generate_field_access_events |
| = potential_capabilities.can_generate_field_access_events; |
| needed_capabilities.can_get_bytecodes |
| = potential_capabilities.can_get_bytecodes; |
| needed_capabilities.can_get_synthetic_attribute |
| = potential_capabilities.can_get_synthetic_attribute; |
| needed_capabilities.can_get_owned_monitor_info |
| = potential_capabilities.can_get_owned_monitor_info; |
| needed_capabilities.can_get_current_contended_monitor |
| = potential_capabilities.can_get_current_contended_monitor; |
| needed_capabilities.can_get_monitor_info |
| = potential_capabilities.can_get_monitor_info; |
| needed_capabilities.can_pop_frame |
| = potential_capabilities.can_pop_frame; |
| needed_capabilities.can_redefine_classes |
| = potential_capabilities.can_redefine_classes; |
| needed_capabilities.can_redefine_any_class |
| = potential_capabilities.can_redefine_any_class; |
| needed_capabilities.can_get_owned_monitor_stack_depth_info |
| = potential_capabilities.can_get_owned_monitor_stack_depth_info; |
| needed_capabilities.can_get_constant_pool |
| = potential_capabilities.can_get_constant_pool; |
| { |
| needed_capabilities.can_get_source_debug_extension = 1; |
| needed_capabilities.can_get_source_file_name = 1; |
| needed_capabilities.can_get_line_numbers = 1; |
| needed_capabilities.can_signal_thread |
| = potential_capabilities.can_signal_thread; |
| } |
| |
| /* Add the capabilities */ |
| error = JVMTI_FUNC_PTR(gdata->jvmti,AddCapabilities) |
| (gdata->jvmti, &needed_capabilities); |
| if (error != JVMTI_ERROR_NONE) { |
| ERROR_MESSAGE(("JDWP unable to get necessary JVMTI capabilities.")); |
| forceExit(1); /* Kill entire process, no core dump wanted */ |
| } |
| |
| /* Initialize event number mapping tables */ |
| eventIndexInit(); |
| |
| /* Set the initial JVMTI event notifications */ |
| error = set_event_notification(JVMTI_ENABLE, EI_VM_DEATH); |
| if (error != JVMTI_ERROR_NONE) { |
| return JNI_ERR; |
| } |
| error = set_event_notification(JVMTI_ENABLE, EI_VM_INIT); |
| if (error != JVMTI_ERROR_NONE) { |
| return JNI_ERR; |
| } |
| if (initOnUncaught || (initOnException != NULL)) { |
| error = set_event_notification(JVMTI_ENABLE, EI_EXCEPTION); |
| if (error != JVMTI_ERROR_NONE) { |
| return JNI_ERR; |
| } |
| } |
| |
| /* Set callbacks just for 3 functions */ |
| (void)memset(&(gdata->callbacks),0,sizeof(gdata->callbacks)); |
| gdata->callbacks.VMInit = &cbEarlyVMInit; |
| gdata->callbacks.VMDeath = &cbEarlyVMDeath; |
| gdata->callbacks.Exception = &cbEarlyException; |
| error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks) |
| (gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks)); |
| if (error != JVMTI_ERROR_NONE) { |
| ERROR_MESSAGE(("JDWP unable to set JVMTI event callbacks: %s(%d)", |
| jvmtiErrorText(error), error)); |
| return JNI_ERR; |
| } |
| |
| LOG_MISC(("OnLoad: DONE")); |
| return JNI_OK; |
| } |
| |
| JNIEXPORT void JNICALL |
| Agent_OnUnload(JavaVM *vm) |
| { |
| |
| gdata->isLoaded = JNI_FALSE; |
| |
| /* Cleanup, but make sure VM is alive before using JNI, and |
| * make sure JVMTI environment is ok before deallocating |
| * memory allocated through JVMTI, which all of it is. |
| */ |
| |
| /* |
| * Close transport before exit |
| */ |
| if (transport_is_open()) { |
| transport_close(); |
| } |
| } |
| |
| /* |
| * Phase 2: Initial events. Phase 2 consists of waiting for the |
| * event that triggers full initialization. Under normal circumstances |
| * (initOnStartup == TRUE) this is the JVMTI_EVENT_VM_INIT event. |
| * Otherwise, we delay initialization until the app throws a |
| * particular exception. The triggering event invokes |
| * the bulk of the initialization, including creation of threads and |
| * monitors, transport setup, and installation of a new event callback which |
| * handles the complete set of events. |
| * |
| * Since the triggering event comes in on an application thread, some of the |
| * initialization is difficult to do here. Specifically, this thread along |
| * with all other app threads may need to be suspended until a debugger |
| * connects. These kinds of tasks are left to the third phase which is |
| * invoked by one of the spawned debugger threads, the event handler. |
| */ |
| |
| /* |
| * Wait for a triggering event; then kick off debugger |
| * initialization. A different event callback will be installed by |
| * debugger initialization, and this function will not be called |
| * again. |
| */ |
| |
| /* |
| * TO DO: Decide whether we need to protect this code with |
| * a lock. It might be too early to create a monitor safely (?). |
| */ |
| |
| static void JNICALL |
| cbEarlyVMInit(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread) |
| { |
| LOG_CB(("cbEarlyVMInit")); |
| if ( gdata->vmDead ) { |
| EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead at VM_INIT time"); |
| } |
| if (initOnStartup) |
| initialize(env, thread, EI_VM_INIT); |
| vmInitialized = JNI_TRUE; |
| LOG_MISC(("END cbEarlyVMInit")); |
| } |
| |
| static void |
| disposeEnvironment(jvmtiEnv *jvmti_env) |
| { |
| jvmtiError error; |
| |
| error = JVMTI_FUNC_PTR(jvmti_env,DisposeEnvironment)(jvmti_env); |
| if ( error == JVMTI_ERROR_MUST_POSSESS_CAPABILITY ) |
| error = JVMTI_ERROR_NONE; /* Hack! FIXUP when JVMTI has disposeEnv */ |
| /* What should error return say? */ |
| if (error != JVMTI_ERROR_NONE) { |
| ERROR_MESSAGE(("JDWP unable to dispose of JVMTI environment: %s(%d)", |
| jvmtiErrorText(error), error)); |
| } |
| gdata->jvmti = NULL; |
| } |
| |
| static void JNICALL |
| cbEarlyVMDeath(jvmtiEnv *jvmti_env, JNIEnv *env) |
| { |
| LOG_CB(("cbEarlyVMDeath")); |
| if ( gdata->vmDead ) { |
| EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM died more than once"); |
| } |
| disposeEnvironment(jvmti_env); |
| gdata->jvmti = NULL; |
| gdata->jvm = NULL; |
| gdata->vmDead = JNI_TRUE; |
| LOG_MISC(("END cbEarlyVMDeath")); |
| } |
| |
| static void JNICALL |
| cbEarlyException(jvmtiEnv *jvmti_env, JNIEnv *env, |
| jthread thread, jmethodID method, jlocation location, |
| jobject exception, |
| jmethodID catch_method, jlocation catch_location) |
| { |
| jvmtiError error; |
| jthrowable currentException; |
| |
| LOG_CB(("cbEarlyException: thread=%p", thread)); |
| |
| if ( gdata->vmDead ) { |
| EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead at initial Exception event"); |
| } |
| if (!vmInitialized) { |
| LOG_MISC(("VM is not initialized yet")); |
| return; |
| } |
| |
| /* |
| * We want to preserve any current exception that might get wiped |
| * out during event handling (e.g. JNI calls). We have to rely on |
| * space for the local reference on the current frame because |
| * doing a PushLocalFrame here might itself generate an exception. |
| */ |
| |
| currentException = JNI_FUNC_PTR(env,ExceptionOccurred)(env); |
| JNI_FUNC_PTR(env,ExceptionClear)(env); |
| |
| if (initOnUncaught && catch_method == NULL) { |
| |
| LOG_MISC(("Initializing on uncaught exception")); |
| initialize(env, thread, EI_EXCEPTION); |
| |
| } else if (initOnException != NULL) { |
| |
| jclass clazz; |
| |
| /* Get class of exception thrown */ |
| clazz = JNI_FUNC_PTR(env,GetObjectClass)(env, exception); |
| if ( clazz != NULL ) { |
| char *signature = NULL; |
| /* initing on throw, check */ |
| error = classSignature(clazz, &signature, NULL); |
| LOG_MISC(("Checking specific exception: looking for %s, got %s", |
| initOnException, signature)); |
| if ( (error==JVMTI_ERROR_NONE) && |
| (strcmp(signature, initOnException) == 0)) { |
| LOG_MISC(("Initializing on specific exception")); |
| initialize(env, thread, EI_EXCEPTION); |
| } else { |
| error = AGENT_ERROR_INTERNAL; /* Just to cause restore */ |
| } |
| if ( signature != NULL ) { |
| jvmtiDeallocate(signature); |
| } |
| } else { |
| error = AGENT_ERROR_INTERNAL; /* Just to cause restore */ |
| } |
| |
| /* If initialize didn't happen, we need to restore things */ |
| if ( error != JVMTI_ERROR_NONE ) { |
| /* |
| * Restore exception state from before callback call |
| */ |
| LOG_MISC(("No initialization, didn't find right exception")); |
| if (currentException != NULL) { |
| JNI_FUNC_PTR(env,Throw)(env, currentException); |
| } else { |
| JNI_FUNC_PTR(env,ExceptionClear)(env); |
| } |
| } |
| |
| } |
| |
| LOG_MISC(("END cbEarlyException")); |
| |
| } |
| |
| typedef struct EnumerateArg { |
| jboolean isServer; |
| jdwpError error; |
| jint startCount; |
| } EnumerateArg; |
| |
| static jboolean |
| startTransport(void *item, void *arg) |
| { |
| TransportSpec *transport = item; |
| EnumerateArg *enumArg = arg; |
| jdwpError serror; |
| |
| LOG_MISC(("Begin startTransport")); |
| serror = transport_startTransport(enumArg->isServer, transport->name, |
| transport->address, transport->timeout); |
| if (serror != JDWP_ERROR(NONE)) { |
| ERROR_MESSAGE(("JDWP Transport %s failed to initialize, %s(%d)", |
| transport->name, jdwpErrorText(serror), serror)); |
| enumArg->error = serror; |
| } else { |
| /* (Don't overwrite any previous error) */ |
| |
| enumArg->startCount++; |
| } |
| |
| LOG_MISC(("End startTransport")); |
| |
| return JNI_TRUE; /* Always continue, even if there was an error */ |
| } |
| |
| static void |
| signalInitComplete(void) |
| { |
| /* |
| * Initialization is complete |
| */ |
| LOG_MISC(("signal initialization complete")); |
| debugMonitorEnter(initMonitor); |
| initComplete = JNI_TRUE; |
| debugMonitorNotifyAll(initMonitor); |
| debugMonitorExit(initMonitor); |
| } |
| |
| /* |
| * Determine if initialization is complete. |
| */ |
| jboolean |
| debugInit_isInitComplete(void) |
| { |
| return initComplete; |
| } |
| |
| /* |
| * Wait for all initialization to complete. |
| */ |
| void |
| debugInit_waitInitComplete(void) |
| { |
| debugMonitorEnter(initMonitor); |
| while (!initComplete) { |
| debugMonitorWait(initMonitor); |
| } |
| debugMonitorExit(initMonitor); |
| } |
| |
| /* All process exit() calls come from here */ |
| void |
| forceExit(int exit_code) |
| { |
| /* make sure the transport is closed down before we exit() */ |
| transport_close(); |
| exit(exit_code); |
| } |
| |
| /* All JVM fatal error exits lead here (e.g. we need to kill the VM). */ |
| static void |
| jniFatalError(JNIEnv *env, const char *msg, jvmtiError error, int exit_code) |
| { |
| JavaVM *vm; |
| char buf[512]; |
| |
| gdata->vmDead = JNI_TRUE; |
| if ( msg==NULL ) |
| msg = "UNKNOWN REASON"; |
| vm = gdata->jvm; |
| if ( env==NULL && vm!=NULL ) { |
| jint rc = (*((*vm)->GetEnv))(vm, (void **)&env, JNI_VERSION_1_2); |
| if (rc != JNI_OK ) { |
| env = NULL; |
| } |
| } |
| if ( error != JVMTI_ERROR_NONE ) { |
| (void)snprintf(buf, sizeof(buf), "JDWP %s, jvmtiError=%s(%d)", |
| msg, jvmtiErrorText(error), error); |
| } else { |
| (void)snprintf(buf, sizeof(buf), "JDWP %s", buf); |
| } |
| if (env != NULL) { |
| (*((*env)->FatalError))(env, buf); |
| } else { |
| /* Should rarely ever reach here, means VM is really dead */ |
| print_message(stderr, "ERROR: JDWP: ", "\n", |
| "Can't call JNI FatalError(NULL, \"%s\")", buf); |
| } |
| forceExit(exit_code); |
| } |
| |
| /* |
| * Initialize debugger back end modules |
| */ |
| static void |
| initialize(JNIEnv *env, jthread thread, EventIndex triggering_ei) |
| { |
| jvmtiError error; |
| EnumerateArg arg; |
| jbyte suspendPolicy; |
| |
| LOG_MISC(("Begin initialize()")); |
| currentSessionID = 0; |
| initComplete = JNI_FALSE; |
| |
| if ( gdata->vmDead ) { |
| EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead at initialize() time"); |
| } |
| |
| /* Turn off the initial JVMTI event notifications */ |
| error = set_event_notification(JVMTI_DISABLE, EI_EXCEPTION); |
| if (error != JVMTI_ERROR_NONE) { |
| EXIT_ERROR(error, "unable to disable JVMTI event notification"); |
| } |
| error = set_event_notification(JVMTI_DISABLE, EI_VM_INIT); |
| if (error != JVMTI_ERROR_NONE) { |
| EXIT_ERROR(error, "unable to disable JVMTI event notification"); |
| } |
| error = set_event_notification(JVMTI_DISABLE, EI_VM_DEATH); |
| if (error != JVMTI_ERROR_NONE) { |
| EXIT_ERROR(error, "unable to disable JVMTI event notification"); |
| } |
| |
| /* Remove initial event callbacks */ |
| (void)memset(&(gdata->callbacks),0,sizeof(gdata->callbacks)); |
| error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks) |
| (gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks)); |
| if (error != JVMTI_ERROR_NONE) { |
| EXIT_ERROR(error, "unable to clear JVMTI callbacks"); |
| } |
| |
| commonRef_initialize(); |
| util_initialize(env); |
| threadControl_initialize(); |
| stepControl_initialize(); |
| invoker_initialize(); |
| debugDispatch_initialize(); |
| classTrack_initialize(env); |
| debugLoop_initialize(); |
| |
| initMonitor = debugMonitorCreate("JDWP Initialization Monitor"); |
| |
| |
| /* |
| * Initialize transports |
| */ |
| arg.isServer = isServer; |
| arg.error = JDWP_ERROR(NONE); |
| arg.startCount = 0; |
| |
| transport_initialize(); |
| (void)bagEnumerateOver(transports, startTransport, &arg); |
| |
| /* |
| * Exit with an error only if |
| * 1) none of the transports was successfully started, and |
| * 2) the application has not yet started running |
| */ |
| if ((arg.error != JDWP_ERROR(NONE)) && |
| (arg.startCount == 0) && |
| initOnStartup) { |
| EXIT_ERROR(map2jvmtiError(arg.error), "No transports initialized"); |
| } |
| |
| eventHandler_initialize(currentSessionID); |
| |
| signalInitComplete(); |
| |
| transport_waitForConnection(); |
| |
| suspendPolicy = suspendOnInit ? JDWP_SUSPEND_POLICY(ALL) |
| : JDWP_SUSPEND_POLICY(NONE); |
| if (triggering_ei == EI_VM_INIT) { |
| LOG_MISC(("triggering_ei == EI_VM_INIT")); |
| eventHelper_reportVMInit(env, currentSessionID, thread, suspendPolicy); |
| } else { |
| /* |
| * TO DO: Kludgy way of getting the triggering event to the |
| * just-attached debugger. It would be nice to make this a little |
| * cleaner. There is also a race condition where other events |
| * can get in the queue (from other not-yet-suspended threads) |
| * before this one does. (Also need to handle allocation error below?) |
| */ |
| EventInfo info; |
| struct bag *initEventBag; |
| LOG_MISC(("triggering_ei != EI_VM_INIT")); |
| initEventBag = eventHelper_createEventBag(); |
| (void)memset(&info,0,sizeof(info)); |
| info.ei = triggering_ei; |
| eventHelper_recordEvent(&info, 0, suspendPolicy, initEventBag); |
| (void)eventHelper_reportEvents(currentSessionID, initEventBag); |
| bagDestroyBag(initEventBag); |
| } |
| |
| if ( gdata->vmDead ) { |
| EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead before initialize() completes"); |
| } |
| LOG_MISC(("End initialize()")); |
| } |
| |
| /* |
| * Restore all static data to the initialized state so that another |
| * debugger can connect properly later. |
| */ |
| void |
| debugInit_reset(JNIEnv *env) |
| { |
| EnumerateArg arg; |
| |
| LOG_MISC(("debugInit_reset() beginning")); |
| |
| currentSessionID++; |
| initComplete = JNI_FALSE; |
| |
| eventHandler_reset(currentSessionID); |
| transport_reset(); |
| debugDispatch_reset(); |
| invoker_reset(); |
| stepControl_reset(); |
| threadControl_reset(); |
| util_reset(); |
| commonRef_reset(env); |
| classTrack_reset(); |
| |
| /* |
| * If this is a server, we are now ready to accept another connection. |
| * If it's a client, then we've cleaned up some (more should be added |
| * later) and we're done. |
| */ |
| if (isServer) { |
| arg.isServer = JNI_TRUE; |
| arg.error = JDWP_ERROR(NONE); |
| arg.startCount = 0; |
| (void)bagEnumerateOver(transports, startTransport, &arg); |
| |
| signalInitComplete(); |
| |
| transport_waitForConnection(); |
| } else { |
| signalInitComplete(); /* Why? */ |
| } |
| |
| LOG_MISC(("debugInit_reset() completed.")); |
| } |
| |
| |
| char * |
| debugInit_launchOnInit(void) |
| { |
| return launchOnInit; |
| } |
| |
| jboolean |
| debugInit_suspendOnInit(void) |
| { |
| return suspendOnInit; |
| } |
| |
| /* |
| * code below is shamelessly swiped from hprof. |
| */ |
| |
| static int |
| get_tok(char **src, char *buf, int buflen, char sep) |
| { |
| int i; |
| char *p = *src; |
| for (i = 0; i < buflen; i++) { |
| if (p[i] == 0 || p[i] == sep) { |
| buf[i] = 0; |
| if (p[i] == sep) { |
| i++; |
| } |
| *src += i; |
| return i; |
| } |
| buf[i] = p[i]; |
| } |
| /* overflow */ |
| return 0; |
| } |
| |
| static void |
| printUsage(void) |
| { |
| TTY_MESSAGE(( |
| " Java Debugger JDWP Agent Library\n" |
| " --------------------------------\n" |
| "\n" |
| " (see http://java.sun.com/products/jpda for more information)\n" |
| "\n" |
| "jdwp usage: java " AGENTLIB "=[help]|[<option>=<value>, ...]\n" |
| "\n" |
| "Option Name and Value Description Default\n" |
| "--------------------- ----------- -------\n" |
| "suspend=y|n wait on startup? y\n" |
| "transport=<name> transport spec none\n" |
| "address=<listen/attach address> transport spec \"\"\n" |
| "server=y|n listen for debugger? n\n" |
| "launch=<command line> run debugger on event none\n" |
| "onthrow=<exception name> debug on throw none\n" |
| "onuncaught=y|n debug on any uncaught? n\n" |
| "timeout=<timeout value> for listen/attach in milliseconds n\n" |
| "mutf8=y|n output modified utf-8 n\n" |
| "quiet=y|n control over terminal messages n\n" |
| "\n" |
| "Obsolete Options\n" |
| "----------------\n" |
| "strict=y|n\n" |
| "stdalloc=y|n\n" |
| "\n" |
| "Examples\n" |
| "--------\n" |
| " - Using sockets connect to a debugger at a specific address:\n" |
| " java " AGENTLIB "=transport=dt_socket,address=localhost:8000 ...\n" |
| " - Using sockets listen for a debugger to attach:\n" |
| " java " AGENTLIB "=transport=dt_socket,server=y,suspend=y ...\n" |
| "\n" |
| "Notes\n" |
| "-----\n" |
| " - A timeout value of 0 (the default) is no timeout.\n" |
| "\n" |
| "Warnings\n" |
| "--------\n" |
| " - The older " XRUN " interface can still be used, but will be removed in\n" |
| " a future release, for example:\n" |
| " java " XDEBUG " " XRUN ":[help]|[<option>=<value>, ...]\n" |
| )); |
| |
| #ifdef DEBUG |
| |
| TTY_MESSAGE(( |
| "\n" |
| "Debugging Options Description Default\n" |
| "----------------- ----------- -------\n" |
| "pause=y|n pause to debug PID n\n" |
| "coredump=y|n coredump at exit n\n" |
| "errorexit=y|n exit on any error n\n" |
| "logfile=filename name of log file none\n" |
| "logflags=flags log flags (bitmask) none\n" |
| " JVM calls = 0x001\n" |
| " JNI calls = 0x002\n" |
| " JVMTI calls = 0x004\n" |
| " misc events = 0x008\n" |
| " step logs = 0x010\n" |
| " locations = 0x020\n" |
| " callbacks = 0x040\n" |
| " errors = 0x080\n" |
| " everything = 0xfff\n" |
| "debugflags=flags debug flags (bitmask) none\n" |
| " USE_ITERATE_THROUGH_HEAP 0x01\n" |
| "\n" |
| "Environment Variables\n" |
| "---------------------\n" |
| "_JAVA_JDWP_OPTIONS\n" |
| " Options can be added externally via this environment variable.\n" |
| " Anything contained in it will get a comma prepended to it (if needed),\n" |
| " then it will be added to the end of the options supplied via the\n" |
| " " XRUN " or " AGENTLIB " command line option.\n" |
| )); |
| |
| #endif |
| |
| |
| |
| } |
| |
| static jboolean checkAddress(void *bagItem, void *arg) |
| { |
| TransportSpec *spec = (TransportSpec *)bagItem; |
| if (spec->address == NULL) { |
| ERROR_MESSAGE(("JDWP Non-server transport %s must have a connection " |
| "address specified through the 'address=' option", |
| spec->name)); |
| return JNI_FALSE; |
| } else { |
| return JNI_TRUE; |
| } |
| } |
| |
| static char * |
| add_to_options(char *options, char *new_options) |
| { |
| size_t originalLength; |
| char *combinedOptions; |
| |
| /* |
| * Allocate enough space for both strings and |
| * comma in between. |
| */ |
| originalLength = strlen(options); |
| combinedOptions = jvmtiAllocate((jint)originalLength + 1 + |
| (jint)strlen(new_options) + 1); |
| if (combinedOptions == NULL) { |
| return NULL; |
| } |
| |
| (void)strcpy(combinedOptions, options); |
| (void)strcat(combinedOptions, ","); |
| (void)strcat(combinedOptions, new_options); |
| |
| return combinedOptions; |
| } |
| |
| static jboolean |
| get_boolean(char **pstr, jboolean *answer) |
| { |
| char buf[80]; |
| *answer = JNI_FALSE; |
| /*LINTED*/ |
| if (get_tok(pstr, buf, (int)sizeof(buf), ',')) { |
| if (strcmp(buf, "y") == 0) { |
| *answer = JNI_TRUE; |
| return JNI_TRUE; |
| } else if (strcmp(buf, "n") == 0) { |
| *answer = JNI_FALSE; |
| return JNI_TRUE; |
| } |
| } |
| return JNI_FALSE; |
| } |
| |
| /* atexit() callback */ |
| static void |
| atexit_finish_logging(void) |
| { |
| /* Normal exit(0) (not _exit()) may only reach here */ |
| finish_logging(0); /* Only first call matters */ |
| } |
| |
| static jboolean |
| parseOptions(char *options) |
| { |
| TransportSpec *currentTransport = NULL; |
| char *end; |
| char *current; |
| int length; |
| char *str; |
| char *errmsg; |
| |
| /* Set defaults */ |
| gdata->assertOn = DEFAULT_ASSERT_ON; |
| gdata->assertFatal = DEFAULT_ASSERT_FATAL; |
| logfile = DEFAULT_LOGFILE; |
| |
| /* Options being NULL will end up being an error. */ |
| if (options == NULL) { |
| options = ""; |
| } |
| |
| /* Check for "help" BEFORE we add any environmental settings */ |
| if ((strcmp(options, "help")) == 0) { |
| printUsage(); |
| forceExit(0); /* Kill entire process, no core dump wanted */ |
| } |
| |
| /* These buffers are never freed */ |
| { |
| char *envOptions; |
| |
| /* |
| * Add environmentally specified options. |
| */ |
| envOptions = getenv("_JAVA_JDWP_OPTIONS"); |
| if (envOptions != NULL) { |
| options = add_to_options(options, envOptions); |
| if ( options==NULL ) { |
| EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options"); |
| } |
| } |
| |
| /* |
| * Allocate a buffer for names derived from option strings. It should |
| * never be longer than the original options string itself. |
| * Also keep a copy of the options in gdata->options. |
| */ |
| length = (int)strlen(options); |
| gdata->options = jvmtiAllocate(length + 1); |
| if (gdata->options == NULL) { |
| EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options"); |
| } |
| (void)strcpy(gdata->options, options); |
| names = jvmtiAllocate(length + 1); |
| if (names == NULL) { |
| EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options"); |
| } |
| |
| transports = bagCreateBag(sizeof(TransportSpec), 3); |
| if (transports == NULL) { |
| EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"transports"); |
| } |
| |
| } |
| |
| current = names; |
| end = names + length; |
| str = options; |
| |
| while (*str) { |
| char buf[100]; |
| /*LINTED*/ |
| if (!get_tok(&str, buf, (int)sizeof(buf), '=')) { |
| goto syntax_error; |
| } |
| if (strcmp(buf, "transport") == 0) { |
| currentTransport = bagAdd(transports); |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| currentTransport->name = current; |
| current += strlen(current) + 1; |
| } else if (strcmp(buf, "address") == 0) { |
| if (currentTransport == NULL) { |
| errmsg = "address specified without transport"; |
| goto bad_option_with_errmsg; |
| } |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| currentTransport->address = current; |
| current += strlen(current) + 1; |
| } else if (strcmp(buf, "timeout") == 0) { |
| if (currentTransport == NULL) { |
| errmsg = "timeout specified without transport"; |
| goto bad_option_with_errmsg; |
| } |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| currentTransport->timeout = atol(current); |
| current += strlen(current) + 1; |
| } else if (strcmp(buf, "launch") == 0) { |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| launchOnInit = current; |
| current += strlen(current) + 1; |
| } else if (strcmp(buf, "onthrow") == 0) { |
| /* Read class name and convert in place to a signature */ |
| *current = 'L'; |
| /*LINTED*/ |
| if (!get_tok(&str, current + 1, (int)(end - current - 1), ',')) { |
| goto syntax_error; |
| } |
| initOnException = current; |
| while (*current != '\0') { |
| if (*current == '.') { |
| *current = '/'; |
| } |
| current++; |
| } |
| *current++ = ';'; |
| *current++ = '\0'; |
| } else if (strcmp(buf, "assert") == 0) { |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| if (strcmp(current, "y") == 0) { |
| gdata->assertOn = JNI_TRUE; |
| gdata->assertFatal = JNI_FALSE; |
| } else if (strcmp(current, "fatal") == 0) { |
| gdata->assertOn = JNI_TRUE; |
| gdata->assertFatal = JNI_TRUE; |
| } else if (strcmp(current, "n") == 0) { |
| gdata->assertOn = JNI_FALSE; |
| gdata->assertFatal = JNI_FALSE; |
| } else { |
| goto syntax_error; |
| } |
| current += strlen(current) + 1; |
| } else if (strcmp(buf, "pause") == 0) { |
| if ( !get_boolean(&str, &dopause) ) { |
| goto syntax_error; |
| } |
| if ( dopause ) { |
| do_pause(); |
| } |
| } else if (strcmp(buf, "coredump") == 0) { |
| if ( !get_boolean(&str, &docoredump) ) { |
| goto syntax_error; |
| } |
| } else if (strcmp(buf, "errorexit") == 0) { |
| if ( !get_boolean(&str, &(gdata->doerrorexit)) ) { |
| goto syntax_error; |
| } |
| } else if (strcmp(buf, "exitpause") == 0) { |
| errmsg = "The exitpause option removed, use -XX:OnError"; |
| goto bad_option_with_errmsg; |
| } else if (strcmp(buf, "precrash") == 0) { |
| errmsg = "The precrash option removed, use -XX:OnError"; |
| goto bad_option_with_errmsg; |
| } else if (strcmp(buf, "logfile") == 0) { |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| logfile = current; |
| current += strlen(current) + 1; |
| } else if (strcmp(buf, "logflags") == 0) { |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| /*LINTED*/ |
| logflags = (unsigned)strtol(current, NULL, 0); |
| } else if (strcmp(buf, "debugflags") == 0) { |
| /*LINTED*/ |
| if (!get_tok(&str, current, (int)(end - current), ',')) { |
| goto syntax_error; |
| } |
| /*LINTED*/ |
| gdata->debugflags = (unsigned)strtol(current, NULL, 0); |
| } else if ( strcmp(buf, "suspend")==0 ) { |
| if ( !get_boolean(&str, &suspendOnInit) ) { |
| goto syntax_error; |
| } |
| } else if ( strcmp(buf, "server")==0 ) { |
| if ( !get_boolean(&str, &isServer) ) { |
| goto syntax_error; |
| } |
| } else if ( strcmp(buf, "strict")==0 ) { /* Obsolete, but accept it */ |
| if ( !get_boolean(&str, &isStrict) ) { |
| goto syntax_error; |
| } |
| } else if ( strcmp(buf, "quiet")==0 ) { |
| if ( !get_boolean(&str, &(gdata->quiet)) ) { |
| goto syntax_error; |
| } |
| } else if ( strcmp(buf, "onuncaught")==0 ) { |
| if ( !get_boolean(&str, &initOnUncaught) ) { |
| goto syntax_error; |
| } |
| } else if ( strcmp(buf, "mutf8")==0 ) { |
| if ( !get_boolean(&str, &(gdata->modifiedUtf8)) ) { |
| goto syntax_error; |
| } |
| } else if ( strcmp(buf, "stdalloc")==0 ) { /* Obsolete, but accept it */ |
| if ( !get_boolean(&str, &useStandardAlloc) ) { |
| goto syntax_error; |
| } |
| } else { |
| goto syntax_error; |
| } |
| } |
| |
| /* Setup logging now */ |
| if ( logfile!=NULL ) { |
| setup_logging(logfile, logflags); |
| (void)atexit(&atexit_finish_logging); |
| } |
| |
| if (bagSize(transports) == 0) { |
| errmsg = "no transport specified"; |
| goto bad_option_with_errmsg; |
| } |
| |
| /* |
| * TO DO: Remove when multiple transports are allowed. (replace with |
| * check below. |
| */ |
| if (bagSize(transports) > 1) { |
| errmsg = "multiple transports are not supported in this release"; |
| goto bad_option_with_errmsg; |
| } |
| |
| |
| if (!isServer) { |
| jboolean specified = bagEnumerateOver(transports, checkAddress, NULL); |
| if (!specified) { |
| /* message already printed */ |
| goto bad_option_no_msg; |
| } |
| } |
| |
| /* |
| * The user has selected to wait for an exception before init happens |
| */ |
| if ((initOnException != NULL) || (initOnUncaught)) { |
| initOnStartup = JNI_FALSE; |
| |
| if (launchOnInit == NULL) { |
| /* |
| * These rely on the launch=/usr/bin/foo |
| * suboption, so it is an error if user did not |
| * provide one. |
| */ |
| errmsg = "Specify launch=<command line> when using onthrow or onuncaught suboption"; |
| goto bad_option_with_errmsg; |
| } |
| } |
| |
| return JNI_TRUE; |
| |
| syntax_error: |
| ERROR_MESSAGE(("JDWP option syntax error: %s=%s", AGENTLIB, options)); |
| return JNI_FALSE; |
| |
| bad_option_with_errmsg: |
| ERROR_MESSAGE(("JDWP %s: %s=%s", errmsg, AGENTLIB, options)); |
| return JNI_FALSE; |
| |
| bad_option_no_msg: |
| ERROR_MESSAGE(("JDWP %s: %s=%s", "invalid option", AGENTLIB, options)); |
| return JNI_FALSE; |
| } |
| |
| /* All normal exit doors lead here */ |
| void |
| debugInit_exit(jvmtiError error, const char *msg) |
| { |
| int exit_code = 0; |
| |
| /* Pick an error code */ |
| if ( error != JVMTI_ERROR_NONE ) { |
| exit_code = 1; |
| if ( docoredump ) { |
| finish_logging(exit_code); |
| abort(); |
| } |
| } |
| if ( msg==NULL ) { |
| msg = ""; |
| } |
| |
| LOG_MISC(("Exiting with error %s(%d): %s", jvmtiErrorText(error), error, msg)); |
| |
| gdata->vmDead = JNI_TRUE; |
| |
| /* Let's try and cleanup the JVMTI, if we even have one */ |
| if ( gdata->jvmti != NULL ) { |
| /* Dispose of jvmti (gdata->jvmti becomes NULL) */ |
| disposeEnvironment(gdata->jvmti); |
| } |
| |
| /* Finish up logging. We reach here if JDWP is doing the exiting. */ |
| finish_logging(exit_code); /* Only first call matters */ |
| |
| /* Let's give the JNI a FatalError if non-exit 0, which is historic way */ |
| if ( exit_code != 0 ) { |
| JNIEnv *env = NULL; |
| jniFatalError(env, msg, error, exit_code); |
| } |
| |
| /* Last chance to die, this kills the entire process. */ |
| forceExit(exit_code); |
| } |
