|
0
|
1 /*
|
|
|
2 * Copyright 2002 Sun Microsystems, Inc. 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.
|
|
|
8 *
|
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
13 * accompanied this code).
|
|
|
14 *
|
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
18 *
|
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 #include <stdio.h>
|
|
|
26 #include <stdarg.h>
|
|
|
27 #include <stdlib.h>
|
|
|
28 #include <vector>
|
|
|
29 #include "sa.hpp"
|
|
|
30 #include "jni.h"
|
|
|
31 #include "jvmdi.h"
|
|
|
32
|
|
|
33 #ifndef WIN32
|
|
|
34 #include <inttypes.h>
|
|
|
35 #else
|
|
|
36 typedef int int32_t;
|
|
|
37 #endif
|
|
|
38
|
|
|
39 #ifdef WIN32
|
|
|
40 #include <windows.h>
|
|
|
41 #define YIELD() Sleep(0)
|
|
|
42 #define SLEEP() Sleep(10)
|
|
|
43 #define vsnprintf _vsnprintf
|
|
|
44 #else
|
|
|
45 Error: please port YIELD() and SLEEP() macros to your platform
|
|
|
46 #endif
|
|
|
47
|
|
|
48 using namespace std;
|
|
|
49
|
|
|
50 //////////////////////////////////////////////////////////////////////
|
|
|
51 // //
|
|
|
52 // Exported "interface" for Java language-level interaction between //
|
|
|
53 // the SA and the VM. Note that the SA knows about the layout of //
|
|
|
54 // certain VM data structures and that knowledge is taken advantage //
|
|
|
55 // of in this code, although this interfaces with the VM via JVMDI. //
|
|
|
56 // //
|
|
|
57 //////////////////////////////////////////////////////////////////////
|
|
|
58
|
|
|
59 extern "C" {
|
|
|
60 /////////////////////////////////////
|
|
|
61 // //
|
|
|
62 // Events sent by the VM to the SA //
|
|
|
63 // //
|
|
|
64 /////////////////////////////////////
|
|
|
65
|
|
|
66 // Set by the SA when it attaches. Indicates that events should be
|
|
|
67 // posted via these exported variables, and that the VM should wait
|
|
|
68 // for those events to be acknowledged by the SA (via its setting
|
|
|
69 // saEventPending to 0).
|
|
|
70 JNIEXPORT volatile int32_t saAttached = 0;
|
|
|
71
|
|
|
72 // Set to nonzero value by the VM when an event has been posted; set
|
|
|
73 // back to 0 by the SA when it has processed that event.
|
|
|
74 JNIEXPORT volatile int32_t saEventPending = 0;
|
|
|
75
|
|
|
76 // Kind of the event (from jvmdi.h)
|
|
|
77 JNIEXPORT volatile int32_t saEventKind = 0;
|
|
|
78
|
|
|
79 //
|
|
|
80 // Exception events
|
|
|
81 //
|
|
|
82 JNIEXPORT jthread saExceptionThread;
|
|
|
83 JNIEXPORT jclass saExceptionClass;
|
|
|
84 JNIEXPORT jmethodID saExceptionMethod;
|
|
|
85 JNIEXPORT int32_t saExceptionLocation;
|
|
|
86 JNIEXPORT jobject saExceptionException;
|
|
|
87 JNIEXPORT jclass saExceptionCatchClass;
|
|
|
88 JNIEXPORT jmethodID saExceptionCatchMethod;
|
|
|
89 JNIEXPORT int32_t saExceptionCatchLocation;
|
|
|
90
|
|
|
91 //
|
|
|
92 // Breakpoint events
|
|
|
93 //
|
|
|
94 JNIEXPORT jthread saBreakpointThread;
|
|
|
95 JNIEXPORT jclass saBreakpointClass;
|
|
|
96 JNIEXPORT jmethodID saBreakpointMethod;
|
|
|
97 JNIEXPORT jlocation saBreakpointLocation;
|
|
|
98
|
|
|
99 ///////////////////////////////////////
|
|
|
100 // //
|
|
|
101 // Commands sent by the SA to the VM //
|
|
|
102 // //
|
|
|
103 ///////////////////////////////////////
|
|
|
104
|
|
|
105 extern JNIEXPORT const int32_t SA_CMD_SUSPEND_ALL = 0;
|
|
|
106 extern JNIEXPORT const int32_t SA_CMD_RESUME_ALL = 1;
|
|
|
107 extern JNIEXPORT const int32_t SA_CMD_TOGGLE_BREAKPOINT = 2;
|
|
|
108 extern JNIEXPORT const int32_t SA_CMD_BUF_SIZE = 1024;
|
|
|
109
|
|
|
110 // SA sets this to a nonzero value when it is requesting a command
|
|
|
111 // to be processed; VM sets it back to 0 when the command has been
|
|
|
112 // executed
|
|
|
113 JNIEXPORT volatile int32_t saCmdPending = 0;
|
|
|
114
|
|
|
115 // SA sets this to one of the manifest constants above to indicate
|
|
|
116 // the kind of command to be executed
|
|
|
117 JNIEXPORT volatile int32_t saCmdType = 0;
|
|
|
118
|
|
|
119 // VM sets this to 0 if the last command succeeded or a nonzero
|
|
|
120 // value if it failed
|
|
|
121 JNIEXPORT volatile int32_t saCmdResult = 0;
|
|
|
122
|
|
|
123 // If last command failed, this buffer will contain a descriptive
|
|
|
124 // error message
|
|
|
125 JNIEXPORT char saCmdResultErrMsg[SA_CMD_BUF_SIZE];
|
|
|
126
|
|
|
127 //
|
|
|
128 // Toggling of breakpoint command arguments.
|
|
|
129 //
|
|
|
130 // Originally there were separate set/clear breakpoint commands
|
|
|
131 // taking a class name, method name and signature, and the iteration
|
|
|
132 // through the debug information was done in the SA. It turns out
|
|
|
133 // that doing this work in the target VM is significantly faster,
|
|
|
134 // and since interactivity when setting and clearing breakpoints is
|
|
|
135 // important, the solution which resulted in more C/C++ code was used.
|
|
|
136 //
|
|
|
137
|
|
|
138 // Source file name
|
|
|
139 JNIEXPORT char saCmdBkptSrcFileName[SA_CMD_BUF_SIZE];
|
|
|
140
|
|
|
141 // Package name ('/' as separator instead of '.')
|
|
|
142 JNIEXPORT char saCmdBkptPkgName[SA_CMD_BUF_SIZE];
|
|
|
143
|
|
|
144 // Line number
|
|
|
145 JNIEXPORT int32_t saCmdBkptLineNumber;
|
|
|
146
|
|
|
147 // Output back to SA: indicator whether the last failure of a
|
|
|
148 // breakpoint toggle command was really an error or just a lack of
|
|
|
149 // debug information covering the requested line. 0 if not error.
|
|
|
150 // Valid only if saCmdResult != 0.
|
|
|
151 JNIEXPORT int32_t saCmdBkptResWasError;
|
|
|
152
|
|
|
153 // Output back to SA: resulting line number at which the breakpoint
|
|
|
154 // was set or cleared (valid only if saCmdResult == 0)
|
|
|
155 JNIEXPORT int32_t saCmdBkptResLineNumber;
|
|
|
156
|
|
|
157 // Output back to SA: resulting byte code index at which the
|
|
|
158 // breakpoint was set or cleared (valid only if saCmdResult == 0)
|
|
|
159 JNIEXPORT int32_t saCmdBkptResBCI;
|
|
|
160
|
|
|
161 // Output back to SA: indicator whether the breakpoint operation
|
|
|
162 // resulted in a set or cleared breakpoint; nonzero if set, zero if
|
|
|
163 // cleared (valid only if saCmdResult == 0)
|
|
|
164 JNIEXPORT int32_t saCmdBkptResWasSet;
|
|
|
165
|
|
|
166 // Output back to SA: method name the breakpoint was set in (valid
|
|
|
167 // only if saCmdResult == 0)
|
|
|
168 JNIEXPORT char saCmdBkptResMethodName[SA_CMD_BUF_SIZE];
|
|
|
169
|
|
|
170 // Output back to SA: method signature (JNI style) the breakpoint
|
|
|
171 // was set in (valid only if saCmdResult == 0)
|
|
|
172 JNIEXPORT char saCmdBkptResMethodSig[SA_CMD_BUF_SIZE];
|
|
|
173 }
|
|
|
174
|
|
|
175 // Internal state
|
|
|
176 static JavaVM* jvm = NULL;
|
|
|
177 static JVMDI_Interface_1* jvmdi = NULL;
|
|
|
178 static jthread debugThreadObj = NULL;
|
|
|
179 static bool suspended = false;
|
|
|
180 static vector<jthread> suspendedThreads;
|
|
|
181 static JVMDI_RawMonitor eventLock = NULL;
|
|
|
182
|
|
|
183 class MonitorLocker {
|
|
|
184 private:
|
|
|
185 JVMDI_RawMonitor lock;
|
|
|
186 public:
|
|
|
187 MonitorLocker(JVMDI_RawMonitor lock) {
|
|
|
188 this->lock = lock;
|
|
|
189 if (lock != NULL) {
|
|
|
190 jvmdi->RawMonitorEnter(lock);
|
|
|
191 }
|
|
|
192 }
|
|
|
193 ~MonitorLocker() {
|
|
|
194 if (lock != NULL) {
|
|
|
195 jvmdi->RawMonitorExit(lock);
|
|
|
196 }
|
|
|
197 }
|
|
|
198 };
|
|
|
199
|
|
|
200 class JvmdiDeallocator {
|
|
|
201 private:
|
|
|
202 void* ptr;
|
|
|
203 public:
|
|
|
204 JvmdiDeallocator(void* ptr) {
|
|
|
205 this->ptr = ptr;
|
|
|
206 }
|
|
|
207 ~JvmdiDeallocator() {
|
|
|
208 jvmdi->Deallocate((jbyte*) ptr);
|
|
|
209 }
|
|
|
210 };
|
|
|
211
|
|
|
212 class JvmdiRefListDeallocator {
|
|
|
213 private:
|
|
|
214 JNIEnv* env;
|
|
|
215 jobject* refList;
|
|
|
216 jint refCount;
|
|
|
217 public:
|
|
|
218 JvmdiRefListDeallocator(JNIEnv* env, jobject* refList, jint refCount) {
|
|
|
219 this->env = env;
|
|
|
220 this->refList = refList;
|
|
|
221 this->refCount = refCount;
|
|
|
222 }
|
|
|
223 ~JvmdiRefListDeallocator() {
|
|
|
224 for (int i = 0; i < refCount; i++) {
|
|
|
225 env->DeleteGlobalRef(refList[i]);
|
|
|
226 }
|
|
|
227 jvmdi->Deallocate((jbyte*) refList);
|
|
|
228 }
|
|
|
229 };
|
|
|
230
|
|
|
231 static void
|
|
|
232 stop(char* msg) {
|
|
|
233 fprintf(stderr, "%s", msg);
|
|
|
234 fprintf(stderr, "\n");
|
|
|
235 exit(1);
|
|
|
236 }
|
|
|
237
|
|
|
238 // This fills in the command result error message, sets the command
|
|
|
239 // result to -1, and clears the pending command flag
|
|
|
240 static void
|
|
|
241 reportErrorToSA(const char* str, ...) {
|
|
|
242 va_list varargs;
|
|
|
243 va_start(varargs, str);
|
|
|
244 vsnprintf(saCmdResultErrMsg, sizeof(saCmdResultErrMsg), str, varargs);
|
|
|
245 va_end(varargs);
|
|
|
246 saCmdResult = -1;
|
|
|
247 saCmdPending = 0;
|
|
|
248 }
|
|
|
249
|
|
|
250 static bool
|
|
|
251 packageNameMatches(char* clazzName, char* pkg) {
|
|
|
252 int pkgLen = strlen(pkg);
|
|
|
253 int clazzNameLen = strlen(clazzName);
|
|
|
254
|
|
|
255 if (pkgLen >= clazzNameLen + 1) {
|
|
|
256 return false;
|
|
|
257 }
|
|
|
258
|
|
|
259 if (strncmp(clazzName, pkg, pkgLen)) {
|
|
|
260 return false;
|
|
|
261 }
|
|
|
262
|
|
|
263 // Ensure that '/' is the next character if non-empty package name
|
|
|
264 int l = pkgLen;
|
|
|
265 if (l > 0) {
|
|
|
266 if (clazzName[l] != '/') {
|
|
|
267 return false;
|
|
|
268 }
|
|
|
269 l++;
|
|
|
270 }
|
|
|
271 // Ensure that there are no more trailing slashes
|
|
|
272 while (l < clazzNameLen) {
|
|
|
273 if (clazzName[l++] == '/') {
|
|
|
274 return false;
|
|
|
275 }
|
|
|
276 }
|
|
|
277 return true;
|
|
|
278 }
|
|
|
279
|
|
|
280 static void
|
|
|
281 executeOneCommand(JNIEnv* env) {
|
|
|
282 switch (saCmdType) {
|
|
|
283 case SA_CMD_SUSPEND_ALL: {
|
|
|
284 if (suspended) {
|
|
|
285 reportErrorToSA("Target process already suspended");
|
|
|
286 return;
|
|
|
287 }
|
|
|
288
|
|
|
289 // We implement this by getting all of the threads and calling
|
|
|
290 // SuspendThread on each one, except for the thread object
|
|
|
291 // corresponding to this thread. Each thread for which the call
|
|
|
292 // succeeded (i.e., did not return JVMDI_ERROR_INVALID_THREAD)
|
|
|
293 // is added to a list which is remembered for later resumption.
|
|
|
294 // Note that this currently has race conditions since a thread
|
|
|
295 // might be started after we call GetAllThreads and since a
|
|
|
296 // thread for which we got an error earlier might be resumed by
|
|
|
297 // the VM while we are busy suspending other threads. We could
|
|
|
298 // solve this by looping until there are no more threads we can
|
|
|
299 // suspend, but a more robust and scalable solution is to add
|
|
|
300 // this functionality to the JVMDI interface (i.e.,
|
|
|
301 // "suspendAll"). Probably need to provide an exclude list for
|
|
|
302 // such a routine.
|
|
|
303 jint threadCount;
|
|
|
304 jthread* threads;
|
|
|
305 if (jvmdi->GetAllThreads(&threadCount, &threads) != JVMDI_ERROR_NONE) {
|
|
|
306 reportErrorToSA("Error while getting thread list");
|
|
|
307 return;
|
|
|
308 }
|
|
|
309
|
|
|
310
|
|
|
311 for (int i = 0; i < threadCount; i++) {
|
|
|
312 jthread thr = threads[i];
|
|
|
313 if (!env->IsSameObject(thr, debugThreadObj)) {
|
|
|
314 jvmdiError err = jvmdi->SuspendThread(thr);
|
|
|
315 if (err == JVMDI_ERROR_NONE) {
|
|
|
316 // Remember this thread and do not free it
|
|
|
317 suspendedThreads.push_back(thr);
|
|
|
318 continue;
|
|
|
319 } else {
|
|
|
320 fprintf(stderr, " SA: Error %d while suspending thread\n", err);
|
|
|
321 // FIXME: stop, resume all threads, report error
|
|
|
322 }
|
|
|
323 }
|
|
|
324 env->DeleteGlobalRef(thr);
|
|
|
325 }
|
|
|
326
|
|
|
327 // Free up threads
|
|
|
328 jvmdi->Deallocate((jbyte*) threads);
|
|
|
329
|
|
|
330 // Suspension is complete
|
|
|
331 suspended = true;
|
|
|
332 break;
|
|
|
333 }
|
|
|
334
|
|
|
335 case SA_CMD_RESUME_ALL: {
|
|
|
336 if (!suspended) {
|
|
|
337 reportErrorToSA("Target process already suspended");
|
|
|
338 return;
|
|
|
339 }
|
|
|
340
|
|
|
341 saCmdResult = 0;
|
|
|
342 bool errorOccurred = false;
|
|
|
343 jvmdiError firstError;
|
|
|
344 for (int i = 0; i < suspendedThreads.size(); i++) {
|
|
|
345 jthread thr = suspendedThreads[i];
|
|
|
346 jvmdiError err = jvmdi->ResumeThread(thr);
|
|
|
347 env->DeleteGlobalRef(thr);
|
|
|
348 if (err != JVMDI_ERROR_NONE) {
|
|
|
349 if (!errorOccurred) {
|
|
|
350 errorOccurred = true;
|
|
|
351 firstError = err;
|
|
|
352 }
|
|
|
353 }
|
|
|
354 }
|
|
|
355 suspendedThreads.clear();
|
|
|
356 suspended = false;
|
|
|
357 if (errorOccurred) {
|
|
|
358 reportErrorToSA("Error %d while resuming threads", firstError);
|
|
|
359 return;
|
|
|
360 }
|
|
|
361 break;
|
|
|
362 }
|
|
|
363
|
|
|
364 case SA_CMD_TOGGLE_BREAKPOINT: {
|
|
|
365 saCmdBkptResWasError = 1;
|
|
|
366
|
|
|
367 // Search line number info for all loaded classes
|
|
|
368 jint classCount;
|
|
|
369 jclass* classes;
|
|
|
370
|
|
|
371 jvmdiError glcRes = jvmdi->GetLoadedClasses(&classCount, &classes);
|
|
|
372 if (glcRes != JVMDI_ERROR_NONE) {
|
|
|
373 reportErrorToSA("Error %d while getting loaded classes", glcRes);
|
|
|
374 return;
|
|
|
375 }
|
|
|
376 JvmdiRefListDeallocator rld(env, (jobject*) classes, classCount);
|
|
|
377
|
|
|
378 bool done = false;
|
|
|
379 bool gotOne = false;
|
|
|
380 jclass targetClass;
|
|
|
381 jmethodID targetMethod;
|
|
|
382 jlocation targetLocation;
|
|
|
383 jint targetLineNumber;
|
|
|
384
|
|
|
385 for (int i = 0; i < classCount && !done; i++) {
|
|
|
386 fflush(stderr);
|
|
|
387 jclass clazz = classes[i];
|
|
|
388 char* srcName;
|
|
|
389 jvmdiError sfnRes = jvmdi->GetSourceFileName(clazz, &srcName);
|
|
|
390 if (sfnRes == JVMDI_ERROR_NONE) {
|
|
|
391 JvmdiDeallocator de1(srcName);
|
|
|
392 if (!strcmp(srcName, saCmdBkptSrcFileName)) {
|
|
|
393 // Got a match. Now see whether the package name of the class also matches
|
|
|
394 char* clazzName;
|
|
|
395 jvmdiError sigRes = jvmdi->GetClassSignature(clazz, &clazzName);
|
|
|
396 if (sigRes != JVMDI_ERROR_NONE) {
|
|
|
397 reportErrorToSA("Error %d while getting a class's signature", sigRes);
|
|
|
398 return;
|
|
|
399 }
|
|
|
400 JvmdiDeallocator de2(clazzName);
|
|
|
401 if (packageNameMatches(clazzName + 1, saCmdBkptPkgName)) {
|
|
|
402 // Iterate through all methods
|
|
|
403 jint methodCount;
|
|
|
404 jmethodID* methods;
|
|
|
405 if (jvmdi->GetClassMethods(clazz, &methodCount, &methods) != JVMDI_ERROR_NONE) {
|
|
|
406 reportErrorToSA("Error while getting methods of class %s", clazzName);
|
|
|
407 return;
|
|
|
408 }
|
|
|
409 JvmdiDeallocator de3(methods);
|
|
|
410 for (int j = 0; j < methodCount && !done; j++) {
|
|
|
411 jmethodID m = methods[j];
|
|
|
412 jint entryCount;
|
|
|
413 JVMDI_line_number_entry* table;
|
|
|
414 jvmdiError lnRes = jvmdi->GetLineNumberTable(clazz, m, &entryCount, &table);
|
|
|
415 if (lnRes == JVMDI_ERROR_NONE) {
|
|
|
416 JvmdiDeallocator de4(table);
|
|
|
417 // Look for line number greater than or equal to requested line
|
|
|
418 for (int k = 0; k < entryCount && !done; k++) {
|
|
|
419 JVMDI_line_number_entry& entry = table[k];
|
|
|
420 if (entry.line_number >= saCmdBkptLineNumber &&
|
|
|
421 (!gotOne || entry.line_number < targetLineNumber)) {
|
|
|
422 gotOne = true;
|
|
|
423 targetClass = clazz;
|
|
|
424 targetMethod = m;
|
|
|
425 targetLocation = entry.start_location;
|
|
|
426 targetLineNumber = entry.line_number;
|
|
|
427 done = (targetLineNumber == saCmdBkptLineNumber);
|
|
|
428 }
|
|
|
429 }
|
|
|
430 } else if (lnRes != JVMDI_ERROR_ABSENT_INFORMATION) {
|
|
|
431 reportErrorToSA("Unexpected error %d while fetching line number table", lnRes);
|
|
|
432 return;
|
|
|
433 }
|
|
|
434 }
|
|
|
435 }
|
|
|
436 }
|
|
|
437 } else if (sfnRes != JVMDI_ERROR_ABSENT_INFORMATION) {
|
|
|
438 reportErrorToSA("Unexpected error %d while fetching source file name", sfnRes);
|
|
|
439 return;
|
|
|
440 }
|
|
|
441 }
|
|
|
442
|
|
|
443 bool wasSet = true;
|
|
|
444 if (gotOne) {
|
|
|
445 // Really toggle this breakpoint
|
|
|
446 jvmdiError bpRes;
|
|
|
447 bpRes = jvmdi->SetBreakpoint(targetClass, targetMethod, targetLocation);
|
|
|
448 if (bpRes == JVMDI_ERROR_DUPLICATE) {
|
|
|
449 bpRes = jvmdi->ClearBreakpoint(targetClass, targetMethod, targetLocation);
|
|
|
450 wasSet = false;
|
|
|
451 }
|
|
|
452 if (bpRes != JVMDI_ERROR_NONE) {
|
|
|
453 reportErrorToSA("Unexpected error %d while setting or clearing breakpoint at bci %d, line %d",
|
|
|
454 bpRes, targetLocation, targetLineNumber);
|
|
|
455 return;
|
|
|
456 }
|
|
|
457 } else {
|
|
|
458 saCmdBkptResWasError = 0;
|
|
|
459 reportErrorToSA("No debug information found covering this line");
|
|
|
460 return;
|
|
|
461 }
|
|
|
462
|
|
|
463 // Provide result
|
|
|
464 saCmdBkptResLineNumber = targetLineNumber;
|
|
|
465 saCmdBkptResBCI = targetLocation;
|
|
|
466 saCmdBkptResWasSet = (wasSet ? 1 : 0);
|
|
|
467 {
|
|
|
468 char* methodName;
|
|
|
469 char* methodSig;
|
|
|
470 if (jvmdi->GetMethodName(targetClass, targetMethod, &methodName, &methodSig)
|
|
|
471 == JVMDI_ERROR_NONE) {
|
|
|
472 JvmdiDeallocator mnd(methodName);
|
|
|
473 JvmdiDeallocator msd(methodSig);
|
|
|
474 strncpy(saCmdBkptResMethodName, methodName, SA_CMD_BUF_SIZE);
|
|
|
475 strncpy(saCmdBkptResMethodSig, methodSig, SA_CMD_BUF_SIZE);
|
|
|
476 } else {
|
|
|
477 strncpy(saCmdBkptResMethodName, "<error>", SA_CMD_BUF_SIZE);
|
|
|
478 strncpy(saCmdBkptResMethodSig, "<error>", SA_CMD_BUF_SIZE);
|
|
|
479 }
|
|
|
480 }
|
|
|
481 break;
|
|
|
482 }
|
|
|
483
|
|
|
484 default:
|
|
|
485 reportErrorToSA("Command %d not yet supported", saCmdType);
|
|
|
486 return;
|
|
|
487 }
|
|
|
488
|
|
|
489 // Successful command execution
|
|
|
490 saCmdResult = 0;
|
|
|
491 saCmdPending = 0;
|
|
|
492 }
|
|
|
493
|
|
|
494 static void
|
|
|
495 saCommandThread(void *arg) {
|
|
|
496 JNIEnv* env = NULL;
|
|
|
497 if (jvm->GetEnv((void **) &env, JNI_VERSION_1_2) != JNI_OK) {
|
|
|
498 stop("Error while starting Serviceability Agent "
|
|
|
499 "command thread: could not get JNI environment");
|
|
|
500 }
|
|
|
501
|
|
|
502 while (1) {
|
|
|
503 // Wait for command
|
|
|
504 while (!saCmdPending) {
|
|
|
505 SLEEP();
|
|
|
506 }
|
|
|
507
|
|
|
508 executeOneCommand(env);
|
|
|
509 }
|
|
|
510 }
|
|
|
511
|
|
|
512 static void
|
|
|
513 saEventHook(JNIEnv *env, JVMDI_Event *event)
|
|
|
514 {
|
|
|
515 MonitorLocker ml(eventLock);
|
|
|
516
|
|
|
517 saEventKind = event->kind;
|
|
|
518
|
|
|
519 if (event->kind == JVMDI_EVENT_VM_INIT) {
|
|
|
520 // Create event lock
|
|
|
521 if (jvmdi->CreateRawMonitor("Serviceability Agent Event Lock", &eventLock)
|
|
|
522 != JVMDI_ERROR_NONE) {
|
|
|
523 stop("Unable to create Serviceability Agent's event lock");
|
|
|
524 }
|
|
|
525 // Start thread which receives commands from the SA.
|
|
|
526 jclass threadClass = env->FindClass("java/lang/Thread");
|
|
|
527 if (threadClass == NULL) stop("Unable to find class java/lang/Thread");
|
|
|
528 jstring threadName = env->NewStringUTF("Serviceability Agent Command Thread");
|
|
|
529 if (threadName == NULL) stop("Unable to allocate debug thread name");
|
|
|
530 jmethodID ctor = env->GetMethodID(threadClass, "<init>", "(Ljava/lang/String;)V");
|
|
|
531 if (ctor == NULL) stop("Unable to find appropriate constructor for java/lang/Thread");
|
|
|
532 // Allocate thread object
|
|
|
533 jthread thr = (jthread) env->NewObject(threadClass, ctor, threadName);
|
|
|
534 if (thr == NULL) stop("Unable to allocate debug thread's java/lang/Thread instance");
|
|
|
535 // Remember which thread this is
|
|
|
536 debugThreadObj = env->NewGlobalRef(thr);
|
|
|
537 if (debugThreadObj == NULL) stop("Unable to allocate global ref for debug thread object");
|
|
|
538 // Start thread
|
|
|
539 jvmdiError err;
|
|
|
540 if ((err = jvmdi->RunDebugThread(thr, &saCommandThread, NULL, JVMDI_THREAD_NORM_PRIORITY))
|
|
|
541 != JVMDI_ERROR_NONE) {
|
|
|
542 char buf[256];
|
|
|
543 sprintf(buf, "Error %d while starting debug thread", err);
|
|
|
544 stop(buf);
|
|
|
545 }
|
|
|
546 // OK, initialization is done
|
|
|
547 return;
|
|
|
548 }
|
|
|
549
|
|
|
550 if (!saAttached) {
|
|
|
551 return;
|
|
|
552 }
|
|
|
553
|
|
|
554 switch (event->kind) {
|
|
|
555 case JVMDI_EVENT_EXCEPTION: {
|
|
|
556 fprintf(stderr, "SA: Exception thrown -- ignoring\n");
|
|
|
557 saExceptionThread = event->u.exception.thread;
|
|
|
558 saExceptionClass = event->u.exception.clazz;
|
|
|
559 saExceptionMethod = event->u.exception.method;
|
|
|
560 saExceptionLocation = event->u.exception.location;
|
|
|
561 saExceptionException = event->u.exception.exception;
|
|
|
562 saExceptionCatchClass = event->u.exception.catch_clazz;
|
|
|
563 saExceptionCatchClass = event->u.exception.catch_clazz;
|
|
|
564 saExceptionCatchMethod = event->u.exception.catch_method;
|
|
|
565 saExceptionCatchLocation = event->u.exception.catch_location;
|
|
|
566 // saEventPending = 1;
|
|
|
567 break;
|
|
|
568 }
|
|
|
569
|
|
|
570 case JVMDI_EVENT_BREAKPOINT: {
|
|
|
571 saBreakpointThread = event->u.breakpoint.thread;
|
|
|
572 saBreakpointClass = event->u.breakpoint.clazz;
|
|
|
573 saBreakpointMethod = event->u.breakpoint.method;
|
|
|
574 saBreakpointLocation = event->u.breakpoint.location;
|
|
|
575 saEventPending = 1;
|
|
|
576 break;
|
|
|
577 }
|
|
|
578
|
|
|
579 default:
|
|
|
580 break;
|
|
|
581 }
|
|
|
582
|
|
|
583 while (saAttached && saEventPending) {
|
|
|
584 SLEEP();
|
|
|
585 }
|
|
|
586 }
|
|
|
587
|
|
|
588 extern "C" {
|
|
|
589 JNIEXPORT jint JNICALL
|
|
|
590 JVM_OnLoad(JavaVM *vm, char *options, void *reserved)
|
|
|
591 {
|
|
|
592 jvm = vm;
|
|
|
593 if (jvm->GetEnv((void**) &jvmdi, JVMDI_VERSION_1) != JNI_OK) {
|
|
|
594 return -1;
|
|
|
595 }
|
|
|
596 if (jvmdi->SetEventHook(&saEventHook) != JVMDI_ERROR_NONE) {
|
|
|
597 return -1;
|
|
|
598 }
|
|
|
599 return 0;
|
|
|
600 }
|
|
|
601 };
|
