| /* | |
| * 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); | |
| } |