1 /*
2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include <ctype.h>
27
28 #include "util.h"
29 #include "commonRef.h"
30 #include "debugDispatch.h"
31 #include "eventHandler.h"
32 #include "eventHelper.h"
33 #include "threadControl.h"
34 #include "stepControl.h"
35 #include "transport.h"
36 #include "classTrack.h"
37 #include "debugLoop.h"
38 #include "bag.h"
39 #include "invoker.h"
40 #include "sys.h"
41
42 // ANDROID-CHANGED: Allow us to initialize VMDebug & ddms apis.
43 #include "vmDebug.h"
44 #include "DDMImpl.h"
45
46 /* How the options get to OnLoad: */
47 #define XDEBUG "-Xdebug"
48 #define XRUN "-Xrunjdwp"
49 #define AGENTLIB "-agentlib:jdwp"
50
51 /* Debug version defaults */
52 #ifdef DEBUG
53 #define DEFAULT_ASSERT_ON JNI_TRUE
54 #define DEFAULT_ASSERT_FATAL JNI_TRUE
55 #define DEFAULT_LOGFILE "jdwp.log"
56 #else
57 #define DEFAULT_ASSERT_ON JNI_FALSE
58 #define DEFAULT_ASSERT_FATAL JNI_FALSE
59 #define DEFAULT_LOGFILE NULL
60 #endif
61
62 // ANDROID-CHANGED: Special Art Version to get an ArtTiEnv. This has the same basic api as a
63 // jvmtiEnv but generally has a caveat that everything is best effort.
64 #define ART_TI_VERSION_1_2 (JVMTI_VERSION_1_2 | 0x40000000)
65
66 static jboolean vmInitialized;
67 static jrawMonitorID initMonitor;
68 static jboolean initComplete;
69 static jbyte currentSessionID;
70
71 // ANDROID-CHANGED: We need to support OnAttach for android so use this to let other parts know that
72 // we aren't fully initialized yet.
73 static jboolean isInAttach = JNI_FALSE;
74
75 /*
76 * Options set through the OnLoad options string. All of these values
77 * are set once at VM startup and never reset.
78 */
79 static jboolean isServer = JNI_FALSE; /* Listens for connecting debuggers? */
80 static jboolean isStrict = JNI_FALSE; /* Unused */
81 static jboolean useStandardAlloc = JNI_FALSE; /* Use standard malloc/free? */
82 static struct bag *transports; /* of TransportSpec */
83
84 static jboolean initOnStartup = JNI_TRUE; /* init immediately */
85 static char *initOnException = NULL; /* init when this exception thrown */
86 static jboolean initOnUncaught = JNI_FALSE; /* init when uncaught exc thrown */
87
88 static char *launchOnInit = NULL; /* launch this app during init */
89 static jboolean suspendOnInit = JNI_TRUE; /* suspend all app threads after init */
90 static jboolean dopause = JNI_FALSE; /* pause for debugger attach */
91 static jboolean docoredump = JNI_FALSE; /* core dump on exit */
92 static char *logfile = NULL; /* Name of logfile (if logging) */
93 static unsigned logflags = 0; /* Log flags */
94
95 static char *names; /* strings derived from OnLoad options */
96
97 /*
98 * Elements of the transports bag
99 */
100 typedef struct TransportSpec {
101 char *name;
102 char *address;
103 long timeout;
104 } TransportSpec;
105
106 /*
107 * Forward Refs
108 */
109 static void JNICALL cbEarlyVMInit(jvmtiEnv*, JNIEnv *, jthread);
110 static void JNICALL cbEarlyVMDeath(jvmtiEnv*, JNIEnv *);
111 static void JNICALL cbEarlyException(jvmtiEnv*, JNIEnv *,
112 jthread, jmethodID, jlocation, jobject, jmethodID, jlocation);
113
114 static void initialize(JNIEnv *env, jthread thread, EventIndex triggering_ei);
115 static jboolean parseOptions(char *str);
116
117 /*
118 * Phase 1: Initial load.
119 *
120 * OnLoad is called by the VM immediately after the back-end
121 * library is loaded. We can do very little in this function since
122 * the VM has not completed initialization. So, we parse the JDWP
123 * options and set up a simple initial event callbacks for JVMTI events.
124 * When a triggering event occurs, that callback will begin debugger initialization.
125 */
126
127 /* Get a static area to hold the Global Data */
128 static BackendGlobalData *
get_gdata(void)129 get_gdata(void)
130 {
131 static BackendGlobalData s;
132 (void)memset(&s, 0, sizeof(BackendGlobalData));
133 return &s;
134 }
135
136 static jvmtiError
set_event_notification(jvmtiEventMode mode,EventIndex ei)137 set_event_notification(jvmtiEventMode mode, EventIndex ei)
138 {
139 jvmtiError error;
140 error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode)
141 (gdata->jvmti, mode, eventIndex2jvmti(ei), NULL);
142 if (error != JVMTI_ERROR_NONE) {
143 ERROR_MESSAGE(("JDWP unable to configure initial JVMTI event %s: %s(%d)",
144 eventText(ei), jvmtiErrorText(error), error));
145 }
146 return error;
147 }
148
149 typedef struct {
150 int major;
151 int minor;
152 } version_type;
153
154 typedef struct {
155 version_type runtime;
156 version_type compiletime;
157 } compatible_versions_type;
158
159 /*
160 * List of explicitly compatible JVMTI versions, specified as
161 * { runtime version, compile-time version } pairs. -1 is a wildcard.
162 */
163 static int nof_compatible_versions = 3;
164 static compatible_versions_type compatible_versions_list[] = {
165 /*
166 * FIXUP: Allow version 0 to be compatible with anything
167 * Special check for FCS of 1.0.
168 */
169 { { 0, -1 }, { -1, -1 } },
170 { { -1, -1 }, { 0, -1 } },
171 /*
172 * 1.2 is runtime compatible with 1.1 -- just make sure to check the
173 * version before using any new 1.2 features
174 */
175 { { 1, 1 }, { 1, 2 } }
176 };
177
178
179 /* Logic to determine JVMTI version compatibility */
180 static jboolean
compatible_versions(jint major_runtime,jint minor_runtime,jint major_compiletime,jint minor_compiletime)181 compatible_versions(jint major_runtime, jint minor_runtime,
182 jint major_compiletime, jint minor_compiletime)
183 {
184 /*
185 * First check to see if versions are explicitly compatible via the
186 * list specified above.
187 */
188 int i;
189 for (i = 0; i < nof_compatible_versions; ++i) {
190 version_type runtime = compatible_versions_list[i].runtime;
191 version_type comptime = compatible_versions_list[i].compiletime;
192
193 if ((major_runtime == runtime.major || runtime.major == -1) &&
194 (minor_runtime == runtime.minor || runtime.minor == -1) &&
195 (major_compiletime == comptime.major || comptime.major == -1) &&
196 (minor_compiletime == comptime.minor || comptime.minor == -1)) {
197 return JNI_TRUE;
198 }
199 }
200
201 return major_runtime == major_compiletime &&
202 minor_runtime >= minor_compiletime;
203 }
204
205 // ANDROID-CHANGED: Function to get and set the com.android.art.internal.ddm.process_chunk extension
206 // function. This returns JNI_ERR if something went wrong with searching. If the extension is not
207 // found we return JNI_OK and don't bother updating the gdata pointer.
find_ddm_process_chunk()208 static jint find_ddm_process_chunk()
209 {
210 jvmtiError error;
211 jvmtiExtensionFunctionInfo* extension_info;
212 jint num_extensions;
213 jboolean found;
214 int i;
215 int j;
216
217 found = JNI_FALSE;
218 error = JVMTI_FUNC_PTR(gdata->jvmti,GetExtensionFunctions)
219 (gdata->jvmti, &num_extensions, &extension_info);
220 if (error != JVMTI_ERROR_NONE) {
221 ERROR_MESSAGE(("JDWP Unable to get jvmti extension functions: %s(%d)",
222 jvmtiErrorText(error), error));
223 return JNI_ERR;
224 }
225 // We iterate through every extension function even once we found the one we want in order to
226 // clean them all up as we go.
227 for (i = 0; i < num_extensions; i++) {
228 if (strcmp("com.android.art.internal.ddm.process_chunk", extension_info[i].id) == 0) {
229 gdata->ddm_process_chunk = (DdmProcessChunk) extension_info[i].func;
230 }
231 jvmtiDeallocate(extension_info[i].id);
232 jvmtiDeallocate(extension_info[i].short_description);
233 for (j = 0; j < extension_info[i].param_count; j++) {
234 jvmtiDeallocate(extension_info[i].params[j].name);
235 }
236 jvmtiDeallocate(extension_info[i].params);
237 jvmtiDeallocate(extension_info[i].errors);
238 }
239 jvmtiDeallocate(extension_info);
240 return JNI_OK;
241 }
242
243 /* OnLoad startup:
244 * Returning JNI_ERR will cause the java_g VM to core dump, be careful.
245 */
246 JNIEXPORT jint JNICALL
Agent_OnLoad(JavaVM * vm,char * options,void * reserved)247 Agent_OnLoad(JavaVM *vm, char *options, void *reserved)
248 {
249 jvmtiError error;
250 jvmtiCapabilities needed_capabilities;
251 jvmtiCapabilities potential_capabilities;
252 jint jvmtiCompileTimeMajorVersion;
253 jint jvmtiCompileTimeMinorVersion;
254 jint jvmtiCompileTimeMicroVersion;
255 char *boot_path = NULL;
256 char npt_lib[MAXPATHLEN];
257
258 /* See if it's already loaded */
259 if ( gdata!=NULL && gdata->isLoaded==JNI_TRUE ) {
260 ERROR_MESSAGE(("Cannot load this JVM TI agent twice, check your java command line for duplicate jdwp options."));
261 return JNI_ERR;
262 }
263
264 /* If gdata is defined and the VM died, why are we here? */
265 if ( gdata!=NULL && gdata->vmDead ) {
266 ERROR_MESSAGE(("JDWP unable to load, VM died"));
267 return JNI_ERR;
268 }
269
270 /* Get global data area */
271 gdata = get_gdata();
272 if (gdata == NULL) {
273 ERROR_MESSAGE(("JDWP unable to allocate memory"));
274 return JNI_ERR;
275 }
276 gdata->isLoaded = JNI_TRUE;
277
278 /* Start filling in gdata */
279 gdata->jvm = vm;
280 vmInitialized = JNI_FALSE;
281 gdata->vmDead = JNI_FALSE;
282
283 /* Get the JVMTI Env, IMPORTANT: Do this first! For jvmtiAllocate(). */
284 error = JVM_FUNC_PTR(vm,GetEnv)
285 (vm, (void **)&(gdata->jvmti), JVMTI_VERSION_1);
286 // ANDROID-CHANGED: Check for ART_TI_VERSION_1_2 if we cannot get real JVMTI. This is done only
287 // to support the userdebug debug-anything behavior.
288 if (error != JNI_OK) {
289 ERROR_MESSAGE(("JDWP unable to access JVMTI Version 1 (0x%x),"
290 " retrying using ART_TI instead since this might be a userdebug device."
291 " JNIEnv's GetEnv() returned %d",
292 JVMTI_VERSION_1, error));
293 // Try to get an ArtTiEnv instead
294 error = JVM_FUNC_PTR(vm,GetEnv)
295 (vm, (void **)&(gdata->jvmti), ART_TI_VERSION_1_2);
296 }
297 if (error != JNI_OK) {
298 ERROR_MESSAGE(("JDWP unable to access either JVMTI Version 1 (0x%x)"
299 " or ART_TI_VERSION_1_2 (0x%x),"
300 " is your J2SE a 1.5 or newer version?"
301 " JNIEnv's GetEnv() returned %d",
302 JVMTI_VERSION_1, ART_TI_VERSION_1_2, error));
303 forceExit(1); /* Kill entire process, no core dump */
304 }
305
306 /* Check to make sure the version of jvmti.h we compiled with
307 * matches the runtime version we are using.
308 */
309 jvmtiCompileTimeMajorVersion = ( JVMTI_VERSION & JVMTI_VERSION_MASK_MAJOR )
310 >> JVMTI_VERSION_SHIFT_MAJOR;
311 jvmtiCompileTimeMinorVersion = ( JVMTI_VERSION & JVMTI_VERSION_MASK_MINOR )
312 >> JVMTI_VERSION_SHIFT_MINOR;
313 jvmtiCompileTimeMicroVersion = ( JVMTI_VERSION & JVMTI_VERSION_MASK_MICRO )
314 >> JVMTI_VERSION_SHIFT_MICRO;
315
316 /* Check for compatibility */
317 if ( !compatible_versions(jvmtiMajorVersion(), jvmtiMinorVersion(),
318 jvmtiCompileTimeMajorVersion, jvmtiCompileTimeMinorVersion) ) {
319
320 ERROR_MESSAGE(("This jdwp native library will not work with this VM's "
321 "version of JVMTI (%d.%d.%d), it needs JVMTI %d.%d[.%d].",
322 jvmtiMajorVersion(),
323 jvmtiMinorVersion(),
324 jvmtiMicroVersion(),
325 jvmtiCompileTimeMajorVersion,
326 jvmtiCompileTimeMinorVersion,
327 jvmtiCompileTimeMicroVersion));
328
329 /* Do not let VM get a fatal error, we don't want a core dump here. */
330 forceExit(1); /* Kill entire process, no core dump wanted */
331 }
332
333 // ANDROID-CHANGED: Android uses java.library.path to store all library path information.
334 JVMTI_FUNC_PTR(gdata->jvmti, GetSystemProperty)
335 (gdata->jvmti, (const char *)"java.library.path",
336 &boot_path);
337
338 dbgsysBuildLibName(npt_lib, sizeof(npt_lib), boot_path, NPT_LIBNAME);
339 /* Npt and Utf function init */
340 NPT_INITIALIZE(npt_lib, &(gdata->npt), NPT_VERSION, NULL);
341 jvmtiDeallocate(boot_path);
342 if (gdata->npt == NULL) {
343 ERROR_MESSAGE(("JDWP: unable to initialize NPT library"));
344 return JNI_ERR;
345 }
346 gdata->npt->utf = (gdata->npt->utfInitialize)(NULL);
347 if (gdata->npt->utf == NULL) {
348 ERROR_MESSAGE(("JDWP: UTF function initialization failed"));
349 return JNI_ERR;
350 }
351
352 /* Parse input options */
353 if (!parseOptions(options)) {
354 /* No message necessary, should have been printed out already */
355 /* Do not let VM get a fatal error, we don't want a core dump here. */
356 forceExit(1); /* Kill entire process, no core dump wanted */
357 }
358
359 LOG_MISC(("Onload: %s", options));
360
361 /* Get potential capabilities */
362 (void)memset(&potential_capabilities,0,sizeof(potential_capabilities));
363 error = JVMTI_FUNC_PTR(gdata->jvmti,GetPotentialCapabilities)
364 (gdata->jvmti, &potential_capabilities);
365 if (error != JVMTI_ERROR_NONE) {
366 ERROR_MESSAGE(("JDWP unable to get potential JVMTI capabilities: %s(%d)",
367 jvmtiErrorText(error), error));
368 return JNI_ERR;
369 }
370
371 /* Fill in ones that we must have */
372 (void)memset(&needed_capabilities,0,sizeof(needed_capabilities));
373 needed_capabilities.can_access_local_variables = 1;
374 needed_capabilities.can_generate_single_step_events = 1;
375 needed_capabilities.can_generate_exception_events = 1;
376 needed_capabilities.can_generate_frame_pop_events = 1;
377 needed_capabilities.can_generate_breakpoint_events = 1;
378 needed_capabilities.can_suspend = 1;
379 needed_capabilities.can_generate_method_entry_events = 1;
380 needed_capabilities.can_generate_method_exit_events = 1;
381 needed_capabilities.can_generate_garbage_collection_events = 1;
382 needed_capabilities.can_maintain_original_method_order = 1;
383 needed_capabilities.can_generate_monitor_events = 1;
384 needed_capabilities.can_tag_objects = 1;
385
386 /* And what potential ones that would be nice to have */
387 needed_capabilities.can_force_early_return
388 = potential_capabilities.can_force_early_return;
389 needed_capabilities.can_generate_field_modification_events
390 = potential_capabilities.can_generate_field_modification_events;
391 needed_capabilities.can_generate_field_access_events
392 = potential_capabilities.can_generate_field_access_events;
393 needed_capabilities.can_get_bytecodes
394 = potential_capabilities.can_get_bytecodes;
395 needed_capabilities.can_get_synthetic_attribute
396 = potential_capabilities.can_get_synthetic_attribute;
397 needed_capabilities.can_get_owned_monitor_info
398 = potential_capabilities.can_get_owned_monitor_info;
399 needed_capabilities.can_get_current_contended_monitor
400 = potential_capabilities.can_get_current_contended_monitor;
401 needed_capabilities.can_get_monitor_info
402 = potential_capabilities.can_get_monitor_info;
403 needed_capabilities.can_pop_frame
404 = potential_capabilities.can_pop_frame;
405 needed_capabilities.can_redefine_classes
406 = potential_capabilities.can_redefine_classes;
407 needed_capabilities.can_redefine_any_class
408 = potential_capabilities.can_redefine_any_class;
409 needed_capabilities.can_get_owned_monitor_stack_depth_info
410 = potential_capabilities.can_get_owned_monitor_stack_depth_info;
411 needed_capabilities.can_get_constant_pool
412 = potential_capabilities.can_get_constant_pool;
413 {
414 needed_capabilities.can_get_source_debug_extension = 1;
415 needed_capabilities.can_get_source_file_name = 1;
416 needed_capabilities.can_get_line_numbers = 1;
417 needed_capabilities.can_signal_thread
418 = potential_capabilities.can_signal_thread;
419 }
420
421 /* Add the capabilities */
422 error = JVMTI_FUNC_PTR(gdata->jvmti,AddCapabilities)
423 (gdata->jvmti, &needed_capabilities);
424 if (error != JVMTI_ERROR_NONE) {
425 ERROR_MESSAGE(("JDWP unable to get necessary JVMTI capabilities."));
426 forceExit(1); /* Kill entire process, no core dump wanted */
427 }
428
429 /* Initialize event number mapping tables */
430 eventIndexInit();
431
432 /* Set the initial JVMTI event notifications */
433 error = set_event_notification(JVMTI_ENABLE, EI_VM_DEATH);
434 if (error != JVMTI_ERROR_NONE) {
435 return JNI_ERR;
436 }
437 error = set_event_notification(JVMTI_ENABLE, EI_VM_INIT);
438 if (error != JVMTI_ERROR_NONE) {
439 return JNI_ERR;
440 }
441 if (initOnUncaught || (initOnException != NULL)) {
442 error = set_event_notification(JVMTI_ENABLE, EI_EXCEPTION);
443 if (error != JVMTI_ERROR_NONE) {
444 return JNI_ERR;
445 }
446 }
447
448 /* Set callbacks just for 3 functions */
449 (void)memset(&(gdata->callbacks),0,sizeof(gdata->callbacks));
450 gdata->callbacks.VMInit = &cbEarlyVMInit;
451 gdata->callbacks.VMDeath = &cbEarlyVMDeath;
452 gdata->callbacks.Exception = &cbEarlyException;
453 error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks)
454 (gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks));
455 if (error != JVMTI_ERROR_NONE) {
456 ERROR_MESSAGE(("JDWP unable to set JVMTI event callbacks: %s(%d)",
457 jvmtiErrorText(error), error));
458 return JNI_ERR;
459 }
460
461 // ANDROID-CHANGED: Find com.android.art.internal.ddm.process_chunk function if it exists.
462 if (find_ddm_process_chunk() != JNI_OK) {
463 ERROR_MESSAGE(("Fatal error while attempting to find the "
464 "com.android.art.internal.ddm.process_chunk extension function"));
465 return JNI_ERR;
466 }
467
468 LOG_MISC(("OnLoad: DONE"));
469 return JNI_OK;
470 }
471
472 JNIEXPORT void JNICALL
Agent_OnUnload(JavaVM * vm)473 Agent_OnUnload(JavaVM *vm)
474 {
475
476 gdata->isLoaded = JNI_FALSE;
477
478 /* Cleanup, but make sure VM is alive before using JNI, and
479 * make sure JVMTI environment is ok before deallocating
480 * memory allocated through JVMTI, which all of it is.
481 */
482
483 /*
484 * Close transport before exit
485 */
486 if (transport_is_open()) {
487 transport_close();
488 }
489 }
490
491 /*
492 * Phase 2: Initial events. Phase 2 consists of waiting for the
493 * event that triggers full initialization. Under normal circumstances
494 * (initOnStartup == TRUE) this is the JVMTI_EVENT_VM_INIT event.
495 * Otherwise, we delay initialization until the app throws a
496 * particular exception. The triggering event invokes
497 * the bulk of the initialization, including creation of threads and
498 * monitors, transport setup, and installation of a new event callback which
499 * handles the complete set of events.
500 *
501 * Since the triggering event comes in on an application thread, some of the
502 * initialization is difficult to do here. Specifically, this thread along
503 * with all other app threads may need to be suspended until a debugger
504 * connects. These kinds of tasks are left to the third phase which is
505 * invoked by one of the spawned debugger threads, the event handler.
506 */
507
508 /*
509 * Wait for a triggering event; then kick off debugger
510 * initialization. A different event callback will be installed by
511 * debugger initialization, and this function will not be called
512 * again.
513 */
514
515 /*
516 * TO DO: Decide whether we need to protect this code with
517 * a lock. It might be too early to create a monitor safely (?).
518 */
519
520 static void JNICALL
cbEarlyVMInit(jvmtiEnv * jvmti_env,JNIEnv * env,jthread thread)521 cbEarlyVMInit(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread)
522 {
523 LOG_CB(("cbEarlyVMInit"));
524 if ( gdata->vmDead ) {
525 EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead at VM_INIT time");
526 }
527 if (initOnStartup)
528 initialize(env, thread, EI_VM_INIT);
529 vmInitialized = JNI_TRUE;
530 LOG_MISC(("END cbEarlyVMInit"));
531 }
532
533 static void
disposeEnvironment(jvmtiEnv * jvmti_env)534 disposeEnvironment(jvmtiEnv *jvmti_env)
535 {
536 jvmtiError error;
537
538 error = JVMTI_FUNC_PTR(jvmti_env,DisposeEnvironment)(jvmti_env);
539 if ( error == JVMTI_ERROR_MUST_POSSESS_CAPABILITY )
540 error = JVMTI_ERROR_NONE; /* Hack! FIXUP when JVMTI has disposeEnv */
541 /* What should error return say? */
542 if (error != JVMTI_ERROR_NONE) {
543 ERROR_MESSAGE(("JDWP unable to dispose of JVMTI environment: %s(%d)",
544 jvmtiErrorText(error), error));
545 }
546 gdata->jvmti = NULL;
547 }
548
549 static void JNICALL
cbEarlyVMDeath(jvmtiEnv * jvmti_env,JNIEnv * env)550 cbEarlyVMDeath(jvmtiEnv *jvmti_env, JNIEnv *env)
551 {
552 LOG_CB(("cbEarlyVMDeath"));
553 if ( gdata->vmDead ) {
554 EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM died more than once");
555 }
556 disposeEnvironment(jvmti_env);
557 gdata->jvmti = NULL;
558 gdata->jvm = NULL;
559 gdata->vmDead = JNI_TRUE;
560 LOG_MISC(("END cbEarlyVMDeath"));
561 }
562
563 static void JNICALL
cbEarlyException(jvmtiEnv * jvmti_env,JNIEnv * env,jthread thread,jmethodID method,jlocation location,jobject exception,jmethodID catch_method,jlocation catch_location)564 cbEarlyException(jvmtiEnv *jvmti_env, JNIEnv *env,
565 jthread thread, jmethodID method, jlocation location,
566 jobject exception,
567 jmethodID catch_method, jlocation catch_location)
568 {
569 jvmtiError error;
570 jthrowable currentException;
571
572 LOG_CB(("cbEarlyException: thread=%p", thread));
573
574 if ( gdata->vmDead ) {
575 EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead at initial Exception event");
576 }
577 if (!vmInitialized) {
578 LOG_MISC(("VM is not initialized yet"));
579 return;
580 }
581
582 /*
583 * We want to preserve any current exception that might get wiped
584 * out during event handling (e.g. JNI calls). We have to rely on
585 * space for the local reference on the current frame because
586 * doing a PushLocalFrame here might itself generate an exception.
587 */
588
589 currentException = JNI_FUNC_PTR(env,ExceptionOccurred)(env);
590 JNI_FUNC_PTR(env,ExceptionClear)(env);
591
592 if (initOnUncaught && catch_method == NULL) {
593
594 LOG_MISC(("Initializing on uncaught exception"));
595 initialize(env, thread, EI_EXCEPTION);
596
597 } else if (initOnException != NULL) {
598
599 jclass clazz;
600
601 /* Get class of exception thrown */
602 clazz = JNI_FUNC_PTR(env,GetObjectClass)(env, exception);
603 if ( clazz != NULL ) {
604 char *signature = NULL;
605 /* initing on throw, check */
606 error = classSignature(clazz, &signature, NULL);
607 LOG_MISC(("Checking specific exception: looking for %s, got %s",
608 initOnException, signature));
609 if ( (error==JVMTI_ERROR_NONE) &&
610 (strcmp(signature, initOnException) == 0)) {
611 LOG_MISC(("Initializing on specific exception"));
612 initialize(env, thread, EI_EXCEPTION);
613 } else {
614 error = AGENT_ERROR_INTERNAL; /* Just to cause restore */
615 }
616 if ( signature != NULL ) {
617 jvmtiDeallocate(signature);
618 }
619 } else {
620 error = AGENT_ERROR_INTERNAL; /* Just to cause restore */
621 }
622
623 /* If initialize didn't happen, we need to restore things */
624 if ( error != JVMTI_ERROR_NONE ) {
625 /*
626 * Restore exception state from before callback call
627 */
628 LOG_MISC(("No initialization, didn't find right exception"));
629 if (currentException != NULL) {
630 JNI_FUNC_PTR(env,Throw)(env, currentException);
631 } else {
632 JNI_FUNC_PTR(env,ExceptionClear)(env);
633 }
634 }
635
636 }
637
638 LOG_MISC(("END cbEarlyException"));
639
640 }
641
642 typedef struct EnumerateArg {
643 jboolean isServer;
644 jdwpError error;
645 jint startCount;
646 } EnumerateArg;
647
648 static jboolean
startTransport(void * item,void * arg)649 startTransport(void *item, void *arg)
650 {
651 TransportSpec *transport = item;
652 EnumerateArg *enumArg = arg;
653 jdwpError serror;
654
655 LOG_MISC(("Begin startTransport"));
656 serror = transport_startTransport(enumArg->isServer, transport->name,
657 transport->address, transport->timeout);
658 if (serror != JDWP_ERROR(NONE)) {
659 ERROR_MESSAGE(("JDWP Transport %s failed to initialize, %s(%d)",
660 transport->name, jdwpErrorText(serror), serror));
661 enumArg->error = serror;
662 } else {
663 /* (Don't overwrite any previous error) */
664
665 enumArg->startCount++;
666 }
667
668 LOG_MISC(("End startTransport"));
669
670 return JNI_TRUE; /* Always continue, even if there was an error */
671 }
672
673 static void
signalInitComplete(void)674 signalInitComplete(void)
675 {
676 /*
677 * Initialization is complete
678 */
679 LOG_MISC(("signal initialization complete"));
680 debugMonitorEnter(initMonitor);
681 initComplete = JNI_TRUE;
682 debugMonitorNotifyAll(initMonitor);
683 debugMonitorExit(initMonitor);
684 }
685
686 /*
687 * Determine if initialization is complete.
688 */
689 jboolean
debugInit_isInitComplete(void)690 debugInit_isInitComplete(void)
691 {
692 return initComplete;
693 }
694
695 /*
696 * Wait for all initialization to complete.
697 */
698 void
debugInit_waitInitComplete(void)699 debugInit_waitInitComplete(void)
700 {
701 debugMonitorEnter(initMonitor);
702 while (!initComplete) {
703 debugMonitorWait(initMonitor);
704 }
705 debugMonitorExit(initMonitor);
706 }
707
708 /* All process exit() calls come from here */
709 void
forceExit(int exit_code)710 forceExit(int exit_code)
711 {
712 /* make sure the transport is closed down before we exit() */
713 transport_close();
714 exit(exit_code);
715 }
716
717 /* All JVM fatal error exits lead here (e.g. we need to kill the VM). */
718 static void
jniFatalError(JNIEnv * env,const char * msg,jvmtiError error,int exit_code)719 jniFatalError(JNIEnv *env, const char *msg, jvmtiError error, int exit_code)
720 {
721 JavaVM *vm;
722 char buf[512];
723
724 gdata->vmDead = JNI_TRUE;
725 if ( msg==NULL )
726 msg = "UNKNOWN REASON";
727 vm = gdata->jvm;
728 if ( env==NULL && vm!=NULL ) {
729 jint rc = (*((*vm)->GetEnv))(vm, (void **)&env, JNI_VERSION_1_2);
730 if (rc != JNI_OK ) {
731 env = NULL;
732 }
733 }
734 if ( error != JVMTI_ERROR_NONE ) {
735 (void)snprintf(buf, sizeof(buf), "JDWP %s, jvmtiError=%s(%d)",
736 msg, jvmtiErrorText(error), error);
737 } else {
738 (void)snprintf(buf, sizeof(buf), "JDWP %s", buf);
739 }
740 if (env != NULL) {
741 (*((*env)->FatalError))(env, buf);
742 } else {
743 /* Should rarely ever reach here, means VM is really dead */
744 print_message(stderr, "ERROR: JDWP: ", "\n",
745 "Can't call JNI FatalError(NULL, \"%s\")", buf);
746 }
747 forceExit(exit_code);
748 }
749
750 /*
751 * Initialize debugger back end modules
752 */
753 static void
initialize(JNIEnv * env,jthread thread,EventIndex triggering_ei)754 initialize(JNIEnv *env, jthread thread, EventIndex triggering_ei)
755 {
756 jvmtiError error;
757 EnumerateArg arg;
758 jbyte suspendPolicy;
759
760 LOG_MISC(("Begin initialize()"));
761 currentSessionID = 0;
762 initComplete = JNI_FALSE;
763
764 if ( gdata->vmDead ) {
765 EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead at initialize() time");
766 }
767
768 /* Turn off the initial JVMTI event notifications */
769 error = set_event_notification(JVMTI_DISABLE, EI_EXCEPTION);
770 if (error != JVMTI_ERROR_NONE) {
771 EXIT_ERROR(error, "unable to disable JVMTI event notification");
772 }
773 error = set_event_notification(JVMTI_DISABLE, EI_VM_INIT);
774 if (error != JVMTI_ERROR_NONE) {
775 EXIT_ERROR(error, "unable to disable JVMTI event notification");
776 }
777 error = set_event_notification(JVMTI_DISABLE, EI_VM_DEATH);
778 if (error != JVMTI_ERROR_NONE) {
779 EXIT_ERROR(error, "unable to disable JVMTI event notification");
780 }
781
782 /* Remove initial event callbacks */
783 (void)memset(&(gdata->callbacks),0,sizeof(gdata->callbacks));
784 error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks)
785 (gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks));
786 if (error != JVMTI_ERROR_NONE) {
787 EXIT_ERROR(error, "unable to clear JVMTI callbacks");
788 }
789
790 commonRef_initialize();
791 util_initialize(env);
792 threadControl_initialize();
793 stepControl_initialize();
794 invoker_initialize();
795 debugDispatch_initialize();
796 classTrack_initialize(env);
797 debugLoop_initialize();
798
799 // ANDROID-CHANGED: Set up DDM
800 DDM_initialize();
801
802 // ANDROID-CHANGED: Take over relevant VMDebug APIs.
803 vmDebug_initalize(env);
804
805 initMonitor = debugMonitorCreate("JDWP Initialization Monitor");
806
807
808 /*
809 * Initialize transports
810 */
811 arg.isServer = isServer;
812 arg.error = JDWP_ERROR(NONE);
813 arg.startCount = 0;
814
815 transport_initialize();
816 (void)bagEnumerateOver(transports, startTransport, &arg);
817
818 /*
819 * Exit with an error only if
820 * 1) none of the transports was successfully started, and
821 * 2) the application has not yet started running
822 */
823 if ((arg.error != JDWP_ERROR(NONE)) &&
824 (arg.startCount == 0) &&
825 initOnStartup) {
826 EXIT_ERROR(map2jvmtiError(arg.error), "No transports initialized");
827 }
828
829 eventHandler_initialize(currentSessionID);
830
831 signalInitComplete();
832
833 transport_waitForConnection();
834
835 suspendPolicy = suspendOnInit ? JDWP_SUSPEND_POLICY(ALL)
836 : JDWP_SUSPEND_POLICY(NONE);
837 // ANDROID-CHANGED: Don't send any event if we are actually in Agent_OnAttach.
838 if (isInAttach) {
839 // Do Nothing.
840 } else if (triggering_ei == EI_VM_INIT) {
841 LOG_MISC(("triggering_ei == EI_VM_INIT"));
842 eventHelper_reportVMInit(env, currentSessionID, thread, suspendPolicy);
843 } else {
844 /*
845 * TO DO: Kludgy way of getting the triggering event to the
846 * just-attached debugger. It would be nice to make this a little
847 * cleaner. There is also a race condition where other events
848 * can get in the queue (from other not-yet-suspended threads)
849 * before this one does. (Also need to handle allocation error below?)
850 */
851 EventInfo info;
852 struct bag *initEventBag;
853 LOG_MISC(("triggering_ei != EI_VM_INIT"));
854 initEventBag = eventHelper_createEventBag();
855 (void)memset(&info,0,sizeof(info));
856 info.ei = triggering_ei;
857 eventHelper_recordEvent(&info, 0, suspendPolicy, initEventBag);
858 (void)eventHelper_reportEvents(currentSessionID, initEventBag);
859 bagDestroyBag(initEventBag);
860 }
861
862 if ( gdata->vmDead ) {
863 EXIT_ERROR(AGENT_ERROR_INTERNAL,"VM dead before initialize() completes");
864 }
865 LOG_MISC(("End initialize()"));
866 }
867
868 /*
869 * Restore all static data to the initialized state so that another
870 * debugger can connect properly later.
871 */
872 void
debugInit_reset(JNIEnv * env)873 debugInit_reset(JNIEnv *env)
874 {
875 EnumerateArg arg;
876
877 LOG_MISC(("debugInit_reset() beginning"));
878
879 currentSessionID++;
880 initComplete = JNI_FALSE;
881
882 eventHandler_reset(currentSessionID);
883 transport_reset();
884 debugDispatch_reset();
885 invoker_reset();
886 stepControl_reset();
887 threadControl_reset();
888 util_reset();
889 commonRef_reset(env);
890 classTrack_reset();
891
892 /*
893 * If this is a server, we are now ready to accept another connection.
894 * If it's a client, then we've cleaned up some (more should be added
895 * later) and we're done.
896 */
897 if (isServer) {
898 arg.isServer = JNI_TRUE;
899 arg.error = JDWP_ERROR(NONE);
900 arg.startCount = 0;
901 (void)bagEnumerateOver(transports, startTransport, &arg);
902
903 signalInitComplete();
904
905 transport_waitForConnection();
906 } else {
907 signalInitComplete(); /* Why? */
908 }
909
910 LOG_MISC(("debugInit_reset() completed."));
911 }
912
913
914 char *
debugInit_launchOnInit(void)915 debugInit_launchOnInit(void)
916 {
917 return launchOnInit;
918 }
919
920 jboolean
debugInit_suspendOnInit(void)921 debugInit_suspendOnInit(void)
922 {
923 return suspendOnInit;
924 }
925
926 /*
927 * code below is shamelessly swiped from hprof.
928 */
929
930 static int
get_tok(char ** src,char * buf,int buflen,char sep)931 get_tok(char **src, char *buf, int buflen, char sep)
932 {
933 int i;
934 char *p = *src;
935 for (i = 0; i < buflen; i++) {
936 if (p[i] == 0 || p[i] == sep) {
937 buf[i] = 0;
938 if (p[i] == sep) {
939 i++;
940 }
941 *src += i;
942 return i;
943 }
944 buf[i] = p[i];
945 }
946 /* overflow */
947 return 0;
948 }
949
950 static void
printUsage(void)951 printUsage(void)
952 {
953 TTY_MESSAGE((
954 " Java Debugger JDWP Agent Library\n"
955 " --------------------------------\n"
956 "\n"
957 " (see http://java.sun.com/products/jpda for more information)\n"
958 "\n"
959 "jdwp usage: java " AGENTLIB "=[help]|[<option>=<value>, ...]\n"
960 "\n"
961 "Option Name and Value Description Default\n"
962 "--------------------- ----------- -------\n"
963 "suspend=y|n wait on startup? y\n"
964 "transport=<name> transport spec none\n"
965 "address=<listen/attach address> transport spec \"\"\n"
966 "server=y|n listen for debugger? n\n"
967 "launch=<command line> run debugger on event none\n"
968 "onthrow=<exception name> debug on throw none\n"
969 "onuncaught=y|n debug on any uncaught? n\n"
970 "timeout=<timeout value> for listen/attach in milliseconds n\n"
971 "mutf8=y|n output modified utf-8 n\n"
972 "quiet=y|n control over terminal messages n\n"
973 "\n"
974 "Obsolete Options\n"
975 "----------------\n"
976 "strict=y|n\n"
977 "stdalloc=y|n\n"
978 "\n"
979 "Examples\n"
980 "--------\n"
981 " - Using sockets connect to a debugger at a specific address:\n"
982 " java " AGENTLIB "=transport=dt_socket,address=localhost:8000 ...\n"
983 " - Using sockets listen for a debugger to attach:\n"
984 " java " AGENTLIB "=transport=dt_socket,server=y,suspend=y ...\n"
985 "\n"
986 "Notes\n"
987 "-----\n"
988 " - A timeout value of 0 (the default) is no timeout.\n"
989 "\n"
990 "Warnings\n"
991 "--------\n"
992 " - The older " XRUN " interface can still be used, but will be removed in\n"
993 " a future release, for example:\n"
994 " java " XDEBUG " " XRUN ":[help]|[<option>=<value>, ...]\n"
995 ));
996
997 #ifdef DEBUG
998
999 TTY_MESSAGE((
1000 "\n"
1001 "Debugging Options Description Default\n"
1002 "----------------- ----------- -------\n"
1003 "pause=y|n pause to debug PID n\n"
1004 "coredump=y|n coredump at exit n\n"
1005 "errorexit=y|n exit on any error n\n"
1006 "logfile=filename name of log file none\n"
1007 "logflags=flags log flags (bitmask) none\n"
1008 " JVM calls = 0x001\n"
1009 " JNI calls = 0x002\n"
1010 " JVMTI calls = 0x004\n"
1011 " misc events = 0x008\n"
1012 " step logs = 0x010\n"
1013 " locations = 0x020\n"
1014 " callbacks = 0x040\n"
1015 " errors = 0x080\n"
1016 " everything = 0xfff\n"
1017 "debugflags=flags debug flags (bitmask) none\n"
1018 " USE_ITERATE_THROUGH_HEAP 0x01\n"
1019 "\n"
1020 "Environment Variables\n"
1021 "---------------------\n"
1022 "_JAVA_JDWP_OPTIONS\n"
1023 " Options can be added externally via this environment variable.\n"
1024 " Anything contained in it will get a comma prepended to it (if needed),\n"
1025 " then it will be added to the end of the options supplied via the\n"
1026 " " XRUN " or " AGENTLIB " command line option.\n"
1027 ));
1028
1029 #endif
1030
1031
1032
1033 }
1034
checkAddress(void * bagItem,void * arg)1035 static jboolean checkAddress(void *bagItem, void *arg)
1036 {
1037 TransportSpec *spec = (TransportSpec *)bagItem;
1038 if (spec->address == NULL) {
1039 ERROR_MESSAGE(("JDWP Non-server transport %s must have a connection "
1040 "address specified through the 'address=' option",
1041 spec->name));
1042 return JNI_FALSE;
1043 } else {
1044 return JNI_TRUE;
1045 }
1046 }
1047
1048 static char *
add_to_options(char * options,char * new_options)1049 add_to_options(char *options, char *new_options)
1050 {
1051 size_t originalLength;
1052 char *combinedOptions;
1053
1054 /*
1055 * Allocate enough space for both strings and
1056 * comma in between.
1057 */
1058 originalLength = strlen(options);
1059 combinedOptions = jvmtiAllocate((jint)originalLength + 1 +
1060 (jint)strlen(new_options) + 1);
1061 if (combinedOptions == NULL) {
1062 return NULL;
1063 }
1064
1065 (void)strcpy(combinedOptions, options);
1066 (void)strcat(combinedOptions, ",");
1067 (void)strcat(combinedOptions, new_options);
1068
1069 return combinedOptions;
1070 }
1071
1072 static jboolean
get_boolean(char ** pstr,jboolean * answer)1073 get_boolean(char **pstr, jboolean *answer)
1074 {
1075 char buf[80];
1076 *answer = JNI_FALSE;
1077 /*LINTED*/
1078 if (get_tok(pstr, buf, (int)sizeof(buf), ',')) {
1079 if (strcmp(buf, "y") == 0) {
1080 *answer = JNI_TRUE;
1081 return JNI_TRUE;
1082 } else if (strcmp(buf, "n") == 0) {
1083 *answer = JNI_FALSE;
1084 return JNI_TRUE;
1085 }
1086 }
1087 return JNI_FALSE;
1088 }
1089
1090 /* atexit() callback */
1091 static void
atexit_finish_logging(void)1092 atexit_finish_logging(void)
1093 {
1094 /* Normal exit(0) (not _exit()) may only reach here */
1095 finish_logging(); /* Only first call matters */
1096 }
1097
1098 static jboolean
parseOptions(char * options)1099 parseOptions(char *options)
1100 {
1101 TransportSpec *currentTransport = NULL;
1102 char *end;
1103 char *current;
1104 int length;
1105 char *str;
1106 char *errmsg;
1107
1108 /* Set defaults */
1109 gdata->assertOn = DEFAULT_ASSERT_ON;
1110 gdata->assertFatal = DEFAULT_ASSERT_FATAL;
1111 logfile = DEFAULT_LOGFILE;
1112 // ANDROID-CHANGED: By default we assume ddms is off initially.
1113 gdata->ddmInitiallyActive = JNI_FALSE;
1114
1115 /* Options being NULL will end up being an error. */
1116 if (options == NULL) {
1117 options = "";
1118 }
1119
1120 /* Check for "help" BEFORE we add any environmental settings */
1121 if ((strcmp(options, "help")) == 0) {
1122 printUsage();
1123 forceExit(0); /* Kill entire process, no core dump wanted */
1124 }
1125
1126 /* These buffers are never freed */
1127 {
1128 char *envOptions;
1129
1130 /*
1131 * Add environmentally specified options.
1132 */
1133 envOptions = getenv("_JAVA_JDWP_OPTIONS");
1134 if (envOptions != NULL) {
1135 options = add_to_options(options, envOptions);
1136 if ( options==NULL ) {
1137 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options");
1138 }
1139 }
1140
1141 /*
1142 * Allocate a buffer for names derived from option strings. It should
1143 * never be longer than the original options string itself.
1144 * Also keep a copy of the options in gdata->options.
1145 */
1146 length = (int)strlen(options);
1147 gdata->options = jvmtiAllocate(length + 1);
1148 if (gdata->options == NULL) {
1149 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options");
1150 }
1151 (void)strcpy(gdata->options, options);
1152 names = jvmtiAllocate(length + 1);
1153 if (names == NULL) {
1154 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"options");
1155 }
1156
1157 transports = bagCreateBag(sizeof(TransportSpec), 3);
1158 if (transports == NULL) {
1159 EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"transports");
1160 }
1161
1162 }
1163
1164 current = names;
1165 end = names + length;
1166 str = options;
1167
1168 while (*str) {
1169 char buf[100];
1170 /*LINTED*/
1171 if (!get_tok(&str, buf, (int)sizeof(buf), '=')) {
1172 goto syntax_error;
1173 }
1174 if (strcmp(buf, "transport") == 0) {
1175 currentTransport = bagAdd(transports);
1176 /*LINTED*/
1177 if (!get_tok(&str, current, (int)(end - current), ',')) {
1178 goto syntax_error;
1179 }
1180 currentTransport->name = current;
1181 current += strlen(current) + 1;
1182 } else if (strcmp(buf, "address") == 0) {
1183 if (currentTransport == NULL) {
1184 errmsg = "address specified without transport";
1185 goto bad_option_with_errmsg;
1186 }
1187 /*LINTED*/
1188 if (!get_tok(&str, current, (int)(end - current), ',')) {
1189 goto syntax_error;
1190 }
1191 currentTransport->address = current;
1192 current += strlen(current) + 1;
1193 } else if (strcmp(buf, "timeout") == 0) {
1194 if (currentTransport == NULL) {
1195 errmsg = "timeout specified without transport";
1196 goto bad_option_with_errmsg;
1197 }
1198 /*LINTED*/
1199 if (!get_tok(&str, current, (int)(end - current), ',')) {
1200 goto syntax_error;
1201 }
1202 currentTransport->timeout = atol(current);
1203 current += strlen(current) + 1;
1204 } else if (strcmp(buf, "launch") == 0) {
1205 /*LINTED*/
1206 if (!get_tok(&str, current, (int)(end - current), ',')) {
1207 goto syntax_error;
1208 }
1209 launchOnInit = current;
1210 current += strlen(current) + 1;
1211 } else if (strcmp(buf, "onthrow") == 0) {
1212 /* Read class name and convert in place to a signature */
1213 *current = 'L';
1214 /*LINTED*/
1215 if (!get_tok(&str, current + 1, (int)(end - current - 1), ',')) {
1216 goto syntax_error;
1217 }
1218 initOnException = current;
1219 while (*current != '\0') {
1220 if (*current == '.') {
1221 *current = '/';
1222 }
1223 current++;
1224 }
1225 *current++ = ';';
1226 *current++ = '\0';
1227 } else if (strcmp(buf, "assert") == 0) {
1228 /*LINTED*/
1229 if (!get_tok(&str, current, (int)(end - current), ',')) {
1230 goto syntax_error;
1231 }
1232 if (strcmp(current, "y") == 0) {
1233 gdata->assertOn = JNI_TRUE;
1234 gdata->assertFatal = JNI_FALSE;
1235 } else if (strcmp(current, "fatal") == 0) {
1236 gdata->assertOn = JNI_TRUE;
1237 gdata->assertFatal = JNI_TRUE;
1238 } else if (strcmp(current, "n") == 0) {
1239 gdata->assertOn = JNI_FALSE;
1240 gdata->assertFatal = JNI_FALSE;
1241 } else {
1242 goto syntax_error;
1243 }
1244 current += strlen(current) + 1;
1245 } else if (strcmp(buf, "pause") == 0) {
1246 if ( !get_boolean(&str, &dopause) ) {
1247 goto syntax_error;
1248 }
1249 if ( dopause ) {
1250 do_pause();
1251 }
1252 } else if (strcmp(buf, "coredump") == 0) {
1253 if ( !get_boolean(&str, &docoredump) ) {
1254 goto syntax_error;
1255 }
1256 } else if (strcmp(buf, "errorexit") == 0) {
1257 if ( !get_boolean(&str, &(gdata->doerrorexit)) ) {
1258 goto syntax_error;
1259 }
1260 } else if (strcmp(buf, "exitpause") == 0) {
1261 errmsg = "The exitpause option removed, use -XX:OnError";
1262 goto bad_option_with_errmsg;
1263 } else if (strcmp(buf, "precrash") == 0) {
1264 errmsg = "The precrash option removed, use -XX:OnError";
1265 goto bad_option_with_errmsg;
1266 } else if (strcmp(buf, "logfile") == 0) {
1267 /*LINTED*/
1268 if (!get_tok(&str, current, (int)(end - current), ',')) {
1269 goto syntax_error;
1270 }
1271 logfile = current;
1272 current += strlen(current) + 1;
1273 } else if (strcmp(buf, "logflags") == 0) {
1274 /*LINTED*/
1275 if (!get_tok(&str, current, (int)(end - current), ',')) {
1276 goto syntax_error;
1277 }
1278 /*LINTED*/
1279 logflags = (unsigned)strtol(current, NULL, 0);
1280 } else if (strcmp(buf, "debugflags") == 0) {
1281 /*LINTED*/
1282 if (!get_tok(&str, current, (int)(end - current), ',')) {
1283 goto syntax_error;
1284 }
1285 /*LINTED*/
1286 gdata->debugflags = (unsigned)strtol(current, NULL, 0);
1287 } else if ( strcmp(buf, "suspend")==0 ) {
1288 if ( !get_boolean(&str, &suspendOnInit) ) {
1289 goto syntax_error;
1290 }
1291 } else if ( strcmp(buf, "server")==0 ) {
1292 if ( !get_boolean(&str, &isServer) ) {
1293 goto syntax_error;
1294 }
1295 } else if ( strcmp(buf, "strict")==0 ) { /* Obsolete, but accept it */
1296 if ( !get_boolean(&str, &isStrict) ) {
1297 goto syntax_error;
1298 }
1299 } else if ( strcmp(buf, "quiet")==0 ) {
1300 if ( !get_boolean(&str, &(gdata->quiet)) ) {
1301 goto syntax_error;
1302 }
1303 } else if ( strcmp(buf, "onuncaught")==0 ) {
1304 if ( !get_boolean(&str, &initOnUncaught) ) {
1305 goto syntax_error;
1306 }
1307 } else if ( strcmp(buf, "mutf8")==0 ) {
1308 if ( !get_boolean(&str, &(gdata->modifiedUtf8)) ) {
1309 goto syntax_error;
1310 }
1311 } else if ( strcmp(buf, "stdalloc")==0 ) { /* Obsolete, but accept it */
1312 if ( !get_boolean(&str, &useStandardAlloc) ) {
1313 goto syntax_error;
1314 }
1315 // ANDROID-CHANGED: Need to be able to tell if ddm is initially running.
1316 } else if ( strcmp(buf, "ddm_already_active")==0 ) {
1317 if ( !get_boolean(&str, &(gdata->ddmInitiallyActive)) ) {
1318 goto syntax_error;
1319 }
1320 } else {
1321 goto syntax_error;
1322 }
1323 }
1324
1325 /* Setup logging now */
1326 if ( logfile!=NULL ) {
1327 setup_logging(logfile, logflags);
1328 (void)atexit(&atexit_finish_logging);
1329 }
1330
1331 if (bagSize(transports) == 0) {
1332 errmsg = "no transport specified";
1333 goto bad_option_with_errmsg;
1334 }
1335
1336 /*
1337 * TO DO: Remove when multiple transports are allowed. (replace with
1338 * check below.
1339 */
1340 if (bagSize(transports) > 1) {
1341 errmsg = "multiple transports are not supported in this release";
1342 goto bad_option_with_errmsg;
1343 }
1344
1345
1346 if (!isServer) {
1347 jboolean specified = bagEnumerateOver(transports, checkAddress, NULL);
1348 if (!specified) {
1349 /* message already printed */
1350 goto bad_option_no_msg;
1351 }
1352 }
1353
1354 /*
1355 * The user has selected to wait for an exception before init happens
1356 */
1357 if ((initOnException != NULL) || (initOnUncaught)) {
1358 initOnStartup = JNI_FALSE;
1359
1360 if (launchOnInit == NULL) {
1361 /*
1362 * These rely on the launch=/usr/bin/foo
1363 * suboption, so it is an error if user did not
1364 * provide one.
1365 */
1366 errmsg = "Specify launch=<command line> when using onthrow or onuncaught suboption";
1367 goto bad_option_with_errmsg;
1368 }
1369 }
1370
1371 return JNI_TRUE;
1372
1373 syntax_error:
1374 ERROR_MESSAGE(("JDWP option syntax error: %s=%s", AGENTLIB, options));
1375 return JNI_FALSE;
1376
1377 bad_option_with_errmsg:
1378 ERROR_MESSAGE(("JDWP %s: %s=%s", errmsg, AGENTLIB, options));
1379 return JNI_FALSE;
1380
1381 bad_option_no_msg:
1382 ERROR_MESSAGE(("JDWP %s: %s=%s", "invalid option", AGENTLIB, options));
1383 return JNI_FALSE;
1384 }
1385
1386 /* All normal exit doors lead here */
1387 void
debugInit_exit(jvmtiError error,const char * msg)1388 debugInit_exit(jvmtiError error, const char *msg)
1389 {
1390 enum exit_codes { EXIT_NO_ERRORS = 0, EXIT_JVMTI_ERROR = 1, EXIT_TRANSPORT_ERROR = 2 };
1391
1392 // Prepare to exit. Log error and finish logging
1393 LOG_MISC(("Exiting with error %s(%d): %s", jvmtiErrorText(error), error,
1394 ((msg == NULL) ? "" : msg)));
1395
1396 // coredump requested by command line. Keep JVMTI data dirty
1397 if (error != JVMTI_ERROR_NONE && docoredump) {
1398 LOG_MISC(("Dumping core as requested by command line"));
1399 finish_logging();
1400 abort();
1401 }
1402
1403 finish_logging();
1404
1405 // Cleanup the JVMTI if we have one
1406 if (gdata != NULL) {
1407 gdata->vmDead = JNI_TRUE;
1408 if (gdata->jvmti != NULL) {
1409 // Dispose of jvmti (gdata->jvmti becomes NULL)
1410 disposeEnvironment(gdata->jvmti);
1411 }
1412 }
1413
1414 // We are here with no errors. Kill entire process and exit with zero exit code
1415 if (error == JVMTI_ERROR_NONE) {
1416 forceExit(EXIT_NO_ERRORS);
1417 return;
1418 }
1419
1420 // No transport initilized.
1421 // As we don't have any details here exiting with separate exit code
1422 if (error == AGENT_ERROR_TRANSPORT_INIT) {
1423 forceExit(EXIT_TRANSPORT_ERROR);
1424 return;
1425 }
1426
1427 // We have JVMTI error. Call hotspot jni_FatalError handler
1428 jniFatalError(NULL, msg, error, EXIT_JVMTI_ERROR);
1429
1430 // hotspot calls os:abort() so we should never reach code below,
1431 // but guard against possible hotspot changes
1432
1433 // Last chance to die, this kills the entire process.
1434 forceExit(EXIT_JVMTI_ERROR);
1435 }
1436
1437 // ANDROID-CHANGED: Support jdwp loading with OnAttach.
doInitializeOnAttach(JavaVM * vm)1438 static jint doInitializeOnAttach(JavaVM* vm) {
1439 JNIEnv* jnienv = NULL;
1440 jvmtiError error = JVM_FUNC_PTR(vm,GetEnv)
1441 (vm, (void **)&(jnienv), JNI_VERSION_1_6);
1442 if (error != JNI_OK) {
1443 ERROR_MESSAGE(("JDWP unable to access jni (0x%x),"
1444 " is your J2SE a 1.6 or newer version?"
1445 " JNIEnv's GetEnv() returned %d",
1446 JNI_VERSION_1_6, error));
1447 return JNI_ERR;
1448 }
1449 jthread currentThread;
1450 error = JVMTI_FUNC_PTR(gdata->jvmti,GetCurrentThread)
1451 (gdata->jvmti, ¤tThread);
1452 if (error != JVMTI_ERROR_NONE) {
1453 ERROR_MESSAGE(("JDWP unable to get current thread during agent attach: %s(%d)",
1454 jvmtiErrorText(error), error));
1455 return JNI_ERR;
1456 }
1457 // Pretend to send the VM_INIT event.
1458 cbEarlyVMInit(gdata->jvmti, jnienv, currentThread);
1459 return JNI_OK;
1460 }
1461
1462 /* OnAttach startup:
1463 * ANDROID-CHANGED: We need this to support the way android normally uses debuggers.
1464 */
1465 JNIEXPORT jint JNICALL
Agent_OnAttach(JavaVM * vm,char * options,void * reserved)1466 Agent_OnAttach(JavaVM* vm, char* options, void* reserved)
1467 {
1468 isInAttach = JNI_TRUE;
1469 // SuspendOnInit should default to false in late-attach scenario since it is not supported.
1470 suspendOnInit = JNI_FALSE;
1471 if (Agent_OnLoad(vm, options, reserved) != JNI_OK) {
1472 return JNI_ERR;
1473 }
1474 jint res;
1475 if (suspendOnInit) {
1476 ERROR_MESSAGE(("JDWP cannot suspend all threads when performing late-attach."));
1477 return JNI_ERR;
1478 } else if (!initOnUncaught && (initOnException == NULL)) {
1479 res = doInitializeOnAttach(vm);
1480 } else {
1481 res = JNI_OK;
1482 }
1483 isInAttach = JNI_FALSE;
1484 return res;
1485 }
1486