author | ysuenaga |
Thu, 08 Sep 2016 23:38:56 -0700 | |
changeset 41067 | 77a87b5e001c |
parent 38127 | 2ab00cd4556e |
child 41078 | db508643daab |
permissions | -rw-r--r-- |
1 | 1 |
/* |
36508 | 2 |
* Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5353
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5353
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5353
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "classfile/systemDictionary.hpp" |
|
27 |
#include "code/nmethod.hpp" |
|
28 |
#include "code/pcDesc.hpp" |
|
29 |
#include "code/scopeDesc.hpp" |
|
30 |
#include "interpreter/interpreter.hpp" |
|
31 |
#include "jvmtifiles/jvmtiEnv.hpp" |
|
37992 | 32 |
#include "logging/log.hpp" |
33 |
#include "logging/logStream.hpp" |
|
7397 | 34 |
#include "memory/resourceArea.hpp" |
35 |
#include "oops/objArrayKlass.hpp" |
|
36 |
#include "oops/objArrayOop.hpp" |
|
29081
c61eb4914428
8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents:
27880
diff
changeset
|
37 |
#include "oops/oop.inline.hpp" |
7397 | 38 |
#include "prims/jvmtiCodeBlobEvents.hpp" |
39 |
#include "prims/jvmtiEventController.hpp" |
|
40 |
#include "prims/jvmtiEventController.inline.hpp" |
|
41 |
#include "prims/jvmtiExport.hpp" |
|
42 |
#include "prims/jvmtiImpl.hpp" |
|
43 |
#include "prims/jvmtiManageCapabilities.hpp" |
|
44 |
#include "prims/jvmtiRawMonitor.hpp" |
|
30764 | 45 |
#include "prims/jvmtiRedefineClasses.hpp" |
7397 | 46 |
#include "prims/jvmtiTagMap.hpp" |
47 |
#include "prims/jvmtiThreadState.inline.hpp" |
|
48 |
#include "runtime/arguments.hpp" |
|
49 |
#include "runtime/handles.hpp" |
|
50 |
#include "runtime/interfaceSupport.hpp" |
|
36508 | 51 |
#include "runtime/javaCalls.hpp" |
7397 | 52 |
#include "runtime/objectMonitor.hpp" |
53 |
#include "runtime/objectMonitor.inline.hpp" |
|
25468
5331df506290
8048241: Introduce umbrella header os.inline.hpp and clean up includes
goetz
parents:
24424
diff
changeset
|
54 |
#include "runtime/os.inline.hpp" |
24351
61b33cc6d3cf
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
23447
diff
changeset
|
55 |
#include "runtime/thread.inline.hpp" |
7397 | 56 |
#include "runtime/vframe.hpp" |
57 |
#include "services/attachListener.hpp" |
|
58 |
#include "services/serviceUtil.hpp" |
|
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
15109
diff
changeset
|
59 |
#include "utilities/macros.hpp" |
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
15109
diff
changeset
|
60 |
#if INCLUDE_ALL_GCS |
30764 | 61 |
#include "gc/parallel/psMarkSweep.hpp" |
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
15109
diff
changeset
|
62 |
#endif // INCLUDE_ALL_GCS |
1 | 63 |
|
64 |
#ifdef JVMTI_TRACE |
|
37992 | 65 |
#define EVT_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_SENT) != 0) { SafeResourceMark rm; log_trace(jvmti) out; } |
66 |
#define EVT_TRIG_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_TRIGGER) != 0) { SafeResourceMark rm; log_trace(jvmti) out; } |
|
1 | 67 |
#else |
68 |
#define EVT_TRIG_TRACE(evt,out) |
|
69 |
#define EVT_TRACE(evt,out) |
|
70 |
#endif |
|
71 |
||
72 |
/////////////////////////////////////////////////////////////// |
|
73 |
// |
|
74 |
// JvmtiEventTransition |
|
75 |
// |
|
76 |
// TO DO -- |
|
77 |
// more handle purging |
|
78 |
||
79 |
// Use this for JavaThreads and state is _thread_in_vm. |
|
80 |
class JvmtiJavaThreadEventTransition : StackObj { |
|
81 |
private: |
|
82 |
ResourceMark _rm; |
|
83 |
ThreadToNativeFromVM _transition; |
|
84 |
HandleMark _hm; |
|
85 |
||
86 |
public: |
|
87 |
JvmtiJavaThreadEventTransition(JavaThread *thread) : |
|
88 |
_rm(), |
|
89 |
_transition(thread), |
|
90 |
_hm(thread) {}; |
|
91 |
}; |
|
92 |
||
93 |
// For JavaThreads which are not in _thread_in_vm state |
|
94 |
// and other system threads use this. |
|
95 |
class JvmtiThreadEventTransition : StackObj { |
|
96 |
private: |
|
97 |
ResourceMark _rm; |
|
98 |
HandleMark _hm; |
|
99 |
JavaThreadState _saved_state; |
|
100 |
JavaThread *_jthread; |
|
101 |
||
102 |
public: |
|
103 |
JvmtiThreadEventTransition(Thread *thread) : _rm(), _hm() { |
|
104 |
if (thread->is_Java_thread()) { |
|
105 |
_jthread = (JavaThread *)thread; |
|
106 |
_saved_state = _jthread->thread_state(); |
|
107 |
if (_saved_state == _thread_in_Java) { |
|
108 |
ThreadStateTransition::transition_from_java(_jthread, _thread_in_native); |
|
109 |
} else { |
|
110 |
ThreadStateTransition::transition(_jthread, _saved_state, _thread_in_native); |
|
111 |
} |
|
112 |
} else { |
|
113 |
_jthread = NULL; |
|
114 |
} |
|
115 |
} |
|
116 |
||
117 |
~JvmtiThreadEventTransition() { |
|
118 |
if (_jthread != NULL) |
|
119 |
ThreadStateTransition::transition_from_native(_jthread, _saved_state); |
|
120 |
} |
|
121 |
}; |
|
122 |
||
123 |
||
124 |
/////////////////////////////////////////////////////////////// |
|
125 |
// |
|
126 |
// JvmtiEventMark |
|
127 |
// |
|
128 |
||
129 |
class JvmtiEventMark : public StackObj { |
|
130 |
private: |
|
131 |
JavaThread *_thread; |
|
132 |
JNIEnv* _jni_env; |
|
133 |
bool _exception_detected; |
|
134 |
bool _exception_caught; |
|
135 |
#if 0 |
|
136 |
JNIHandleBlock* _hblock; |
|
137 |
#endif |
|
138 |
||
139 |
public: |
|
140 |
JvmtiEventMark(JavaThread *thread) : _thread(thread), |
|
141 |
_jni_env(thread->jni_environment()) { |
|
142 |
#if 0 |
|
143 |
_hblock = thread->active_handles(); |
|
144 |
_hblock->clear_thoroughly(); // so we can be safe |
|
145 |
#else |
|
146 |
// we want to use the code above - but that needs the JNIHandle changes - later... |
|
147 |
// for now, steal JNI push local frame code |
|
148 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
149 |
// we are before an event. |
|
150 |
// Save current jvmti thread exception state. |
|
151 |
if (state != NULL) { |
|
152 |
_exception_detected = state->is_exception_detected(); |
|
153 |
_exception_caught = state->is_exception_caught(); |
|
154 |
} else { |
|
155 |
_exception_detected = false; |
|
156 |
_exception_caught = false; |
|
157 |
} |
|
158 |
||
159 |
JNIHandleBlock* old_handles = thread->active_handles(); |
|
160 |
JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread); |
|
161 |
assert(new_handles != NULL, "should not be NULL"); |
|
162 |
new_handles->set_pop_frame_link(old_handles); |
|
163 |
thread->set_active_handles(new_handles); |
|
164 |
#endif |
|
165 |
assert(thread == JavaThread::current(), "thread must be current!"); |
|
166 |
thread->frame_anchor()->make_walkable(thread); |
|
167 |
}; |
|
168 |
||
169 |
~JvmtiEventMark() { |
|
170 |
#if 0 |
|
171 |
_hblock->clear(); // for consistency with future correct behavior |
|
172 |
#else |
|
173 |
// we want to use the code above - but that needs the JNIHandle changes - later... |
|
174 |
// for now, steal JNI pop local frame code |
|
175 |
JNIHandleBlock* old_handles = _thread->active_handles(); |
|
176 |
JNIHandleBlock* new_handles = old_handles->pop_frame_link(); |
|
177 |
assert(new_handles != NULL, "should not be NULL"); |
|
178 |
_thread->set_active_handles(new_handles); |
|
179 |
// Note that we set the pop_frame_link to NULL explicitly, otherwise |
|
180 |
// the release_block call will release the blocks. |
|
181 |
old_handles->set_pop_frame_link(NULL); |
|
182 |
JNIHandleBlock::release_block(old_handles, _thread); // may block |
|
183 |
#endif |
|
184 |
||
185 |
JvmtiThreadState* state = _thread->jvmti_thread_state(); |
|
186 |
// we are continuing after an event. |
|
187 |
if (state != NULL) { |
|
188 |
// Restore the jvmti thread exception state. |
|
189 |
if (_exception_detected) { |
|
190 |
state->set_exception_detected(); |
|
191 |
} |
|
192 |
if (_exception_caught) { |
|
193 |
state->set_exception_caught(); |
|
194 |
} |
|
195 |
} |
|
196 |
} |
|
197 |
||
198 |
#if 0 |
|
199 |
jobject to_jobject(oop obj) { return obj == NULL? NULL : _hblock->allocate_handle_fast(obj); } |
|
200 |
#else |
|
201 |
// we want to use the code above - but that needs the JNIHandle changes - later... |
|
202 |
// for now, use regular make_local |
|
203 |
jobject to_jobject(oop obj) { return JNIHandles::make_local(_thread,obj); } |
|
204 |
#endif |
|
205 |
||
14488 | 206 |
jclass to_jclass(Klass* klass) { return (klass == NULL ? NULL : (jclass)to_jobject(klass->java_mirror())); } |
1 | 207 |
|
208 |
jmethodID to_jmethodID(methodHandle method) { return method->jmethod_id(); } |
|
209 |
||
210 |
JNIEnv* jni_env() { return _jni_env; } |
|
211 |
}; |
|
212 |
||
213 |
class JvmtiThreadEventMark : public JvmtiEventMark { |
|
214 |
private: |
|
215 |
jthread _jt; |
|
216 |
||
217 |
public: |
|
218 |
JvmtiThreadEventMark(JavaThread *thread) : |
|
219 |
JvmtiEventMark(thread) { |
|
220 |
_jt = (jthread)(to_jobject(thread->threadObj())); |
|
221 |
}; |
|
222 |
jthread jni_thread() { return _jt; } |
|
223 |
}; |
|
224 |
||
225 |
class JvmtiClassEventMark : public JvmtiThreadEventMark { |
|
226 |
private: |
|
227 |
jclass _jc; |
|
228 |
||
229 |
public: |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
230 |
JvmtiClassEventMark(JavaThread *thread, Klass* klass) : |
1 | 231 |
JvmtiThreadEventMark(thread) { |
232 |
_jc = to_jclass(klass); |
|
233 |
}; |
|
234 |
jclass jni_class() { return _jc; } |
|
235 |
}; |
|
236 |
||
237 |
class JvmtiMethodEventMark : public JvmtiThreadEventMark { |
|
238 |
private: |
|
239 |
jmethodID _mid; |
|
240 |
||
241 |
public: |
|
242 |
JvmtiMethodEventMark(JavaThread *thread, methodHandle method) : |
|
243 |
JvmtiThreadEventMark(thread), |
|
244 |
_mid(to_jmethodID(method)) {}; |
|
245 |
jmethodID jni_methodID() { return _mid; } |
|
246 |
}; |
|
247 |
||
248 |
class JvmtiLocationEventMark : public JvmtiMethodEventMark { |
|
249 |
private: |
|
250 |
jlocation _loc; |
|
251 |
||
252 |
public: |
|
253 |
JvmtiLocationEventMark(JavaThread *thread, methodHandle method, address location) : |
|
254 |
JvmtiMethodEventMark(thread, method), |
|
255 |
_loc(location - method->code_base()) {}; |
|
256 |
jlocation location() { return _loc; } |
|
257 |
}; |
|
258 |
||
259 |
class JvmtiExceptionEventMark : public JvmtiLocationEventMark { |
|
260 |
private: |
|
261 |
jobject _exc; |
|
262 |
||
263 |
public: |
|
264 |
JvmtiExceptionEventMark(JavaThread *thread, methodHandle method, address location, Handle exception) : |
|
265 |
JvmtiLocationEventMark(thread, method, location), |
|
266 |
_exc(to_jobject(exception())) {}; |
|
267 |
jobject exception() { return _exc; } |
|
268 |
}; |
|
269 |
||
270 |
class JvmtiClassFileLoadEventMark : public JvmtiThreadEventMark { |
|
271 |
private: |
|
272 |
const char *_class_name; |
|
273 |
jobject _jloader; |
|
274 |
jobject _protection_domain; |
|
275 |
jclass _class_being_redefined; |
|
276 |
||
277 |
public: |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7918
diff
changeset
|
278 |
JvmtiClassFileLoadEventMark(JavaThread *thread, Symbol* name, |
1 | 279 |
Handle class_loader, Handle prot_domain, KlassHandle *class_being_redefined) : JvmtiThreadEventMark(thread) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7918
diff
changeset
|
280 |
_class_name = name != NULL? name->as_utf8() : NULL; |
1 | 281 |
_jloader = (jobject)to_jobject(class_loader()); |
282 |
_protection_domain = (jobject)to_jobject(prot_domain()); |
|
283 |
if (class_being_redefined == NULL) { |
|
284 |
_class_being_redefined = NULL; |
|
285 |
} else { |
|
286 |
_class_being_redefined = (jclass)to_jclass((*class_being_redefined)()); |
|
287 |
} |
|
288 |
}; |
|
289 |
const char *class_name() { |
|
290 |
return _class_name; |
|
291 |
} |
|
292 |
jobject jloader() { |
|
293 |
return _jloader; |
|
294 |
} |
|
295 |
jobject protection_domain() { |
|
296 |
return _protection_domain; |
|
297 |
} |
|
298 |
jclass class_being_redefined() { |
|
299 |
return _class_being_redefined; |
|
300 |
} |
|
301 |
}; |
|
302 |
||
303 |
////////////////////////////////////////////////////////////////////////////// |
|
304 |
||
305 |
int JvmtiExport::_field_access_count = 0; |
|
306 |
int JvmtiExport::_field_modification_count = 0; |
|
307 |
||
308 |
bool JvmtiExport::_can_access_local_variables = false; |
|
309 |
bool JvmtiExport::_can_hotswap_or_post_breakpoint = false; |
|
310 |
bool JvmtiExport::_can_modify_any_class = false; |
|
311 |
bool JvmtiExport::_can_walk_any_space = false; |
|
312 |
||
313 |
bool JvmtiExport::_has_redefined_a_class = false; |
|
314 |
bool JvmtiExport::_all_dependencies_are_recorded = false; |
|
315 |
||
316 |
// |
|
317 |
// field access management |
|
318 |
// |
|
319 |
||
320 |
// interpreter generator needs the address of the counter |
|
321 |
address JvmtiExport::get_field_access_count_addr() { |
|
322 |
// We don't grab a lock because we don't want to |
|
323 |
// serialize field access between all threads. This means that a |
|
324 |
// thread on another processor can see the wrong count value and |
|
325 |
// may either miss making a needed call into post_field_access() |
|
326 |
// or will make an unneeded call into post_field_access(). We pay |
|
327 |
// this price to avoid slowing down the VM when we aren't watching |
|
328 |
// field accesses. |
|
329 |
// Other access/mutation safe by virtue of being in VM state. |
|
330 |
return (address)(&_field_access_count); |
|
331 |
} |
|
332 |
||
333 |
// |
|
334 |
// field modification management |
|
335 |
// |
|
336 |
||
337 |
// interpreter generator needs the address of the counter |
|
338 |
address JvmtiExport::get_field_modification_count_addr() { |
|
339 |
// We don't grab a lock because we don't |
|
340 |
// want to serialize field modification between all threads. This |
|
341 |
// means that a thread on another processor can see the wrong |
|
342 |
// count value and may either miss making a needed call into |
|
343 |
// post_field_modification() or will make an unneeded call into |
|
344 |
// post_field_modification(). We pay this price to avoid slowing |
|
345 |
// down the VM when we aren't watching field modifications. |
|
346 |
// Other access/mutation safe by virtue of being in VM state. |
|
347 |
return (address)(&_field_modification_count); |
|
348 |
} |
|
349 |
||
350 |
||
351 |
/////////////////////////////////////////////////////////////// |
|
352 |
// Functions needed by java.lang.instrument for starting up javaagent. |
|
353 |
/////////////////////////////////////////////////////////////// |
|
354 |
||
355 |
jint |
|
356 |
JvmtiExport::get_jvmti_interface(JavaVM *jvm, void **penv, jint version) { |
|
4491 | 357 |
// The JVMTI_VERSION_INTERFACE_JVMTI part of the version number |
358 |
// has already been validated in JNI GetEnv(). |
|
359 |
int major, minor, micro; |
|
360 |
||
361 |
// micro version doesn't matter here (yet?) |
|
362 |
decode_version_values(version, &major, &minor, µ); |
|
363 |
switch (major) { |
|
7413 | 364 |
case 1: |
4491 | 365 |
switch (minor) { |
7413 | 366 |
case 0: // version 1.0.<micro> is recognized |
367 |
case 1: // version 1.1.<micro> is recognized |
|
368 |
case 2: // version 1.2.<micro> is recognized |
|
4491 | 369 |
break; |
370 |
||
7413 | 371 |
default: |
4491 | 372 |
return JNI_EVERSION; // unsupported minor version number |
373 |
} |
|
374 |
break; |
|
36508 | 375 |
case 9: |
376 |
switch (minor) { |
|
377 |
case 0: // version 9.0.<micro> is recognized |
|
378 |
break; |
|
379 |
default: |
|
380 |
return JNI_EVERSION; // unsupported minor version number |
|
381 |
} |
|
382 |
break; |
|
7413 | 383 |
default: |
4491 | 384 |
return JNI_EVERSION; // unsupported major version number |
385 |
} |
|
1 | 386 |
|
387 |
if (JvmtiEnv::get_phase() == JVMTI_PHASE_LIVE) { |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
33148
diff
changeset
|
388 |
JavaThread* current_thread = JavaThread::current(); |
1 | 389 |
// transition code: native to VM |
390 |
ThreadInVMfromNative __tiv(current_thread); |
|
10969
3ecf25293e5a
7103224: collision between __LEAF define in interfaceSupport.hpp and /usr/include/sys/cdefs.h with gcc
never
parents:
9405
diff
changeset
|
391 |
VM_ENTRY_BASE(jvmtiEnv*, JvmtiExport::get_jvmti_interface, current_thread) |
1 | 392 |
debug_only(VMNativeEntryWrapper __vew;) |
393 |
||
4491 | 394 |
JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version); |
1 | 395 |
*penv = jvmti_env->jvmti_external(); // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv* |
396 |
return JNI_OK; |
|
397 |
||
398 |
} else if (JvmtiEnv::get_phase() == JVMTI_PHASE_ONLOAD) { |
|
399 |
// not live, no thread to transition |
|
4491 | 400 |
JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version); |
1 | 401 |
*penv = jvmti_env->jvmti_external(); // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv* |
402 |
return JNI_OK; |
|
403 |
||
404 |
} else { |
|
405 |
// Called at the wrong time |
|
406 |
*penv = NULL; |
|
407 |
return JNI_EDETACHED; |
|
408 |
} |
|
409 |
} |
|
410 |
||
36508 | 411 |
void |
412 |
JvmtiExport::add_default_read_edges(Handle h_module, TRAPS) { |
|
413 |
if (!Universe::is_module_initialized()) { |
|
414 |
return; // extra safety |
|
415 |
} |
|
416 |
assert(!h_module.is_null(), "module should always be set"); |
|
417 |
||
418 |
// Invoke the transformedByAgent method |
|
419 |
JavaValue result(T_VOID); |
|
420 |
JavaCalls::call_static(&result, |
|
421 |
SystemDictionary::module_Modules_klass(), |
|
422 |
vmSymbols::transformedByAgent_name(), |
|
423 |
vmSymbols::transformedByAgent_signature(), |
|
424 |
h_module, |
|
425 |
THREAD); |
|
426 |
||
427 |
if (HAS_PENDING_EXCEPTION) { |
|
37992 | 428 |
LogTarget(Trace, jvmti) log; |
429 |
LogStreamCHeap log_stream(log); |
|
430 |
java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream); |
|
38001
6a1924ec5269
8154728: JvmtiExport::add_default_read_edges hits a guarantee
rehn
parents:
37992
diff
changeset
|
431 |
log_stream.cr(); |
36508 | 432 |
CLEAR_PENDING_EXCEPTION; |
433 |
return; |
|
434 |
} |
|
435 |
} |
|
4491 | 436 |
|
437 |
void |
|
438 |
JvmtiExport::decode_version_values(jint version, int * major, int * minor, |
|
439 |
int * micro) { |
|
440 |
*major = (version & JVMTI_VERSION_MASK_MAJOR) >> JVMTI_VERSION_SHIFT_MAJOR; |
|
441 |
*minor = (version & JVMTI_VERSION_MASK_MINOR) >> JVMTI_VERSION_SHIFT_MINOR; |
|
442 |
*micro = (version & JVMTI_VERSION_MASK_MICRO) >> JVMTI_VERSION_SHIFT_MICRO; |
|
443 |
} |
|
444 |
||
1 | 445 |
void JvmtiExport::enter_primordial_phase() { |
446 |
JvmtiEnvBase::set_phase(JVMTI_PHASE_PRIMORDIAL); |
|
447 |
} |
|
448 |
||
36508 | 449 |
void JvmtiExport::enter_early_start_phase() { |
450 |
JvmtiManageCapabilities::recompute_always_capabilities(); |
|
451 |
set_early_vmstart_recorded(true); |
|
452 |
} |
|
453 |
||
1 | 454 |
void JvmtiExport::enter_start_phase() { |
455 |
JvmtiManageCapabilities::recompute_always_capabilities(); |
|
456 |
JvmtiEnvBase::set_phase(JVMTI_PHASE_START); |
|
457 |
} |
|
458 |
||
459 |
void JvmtiExport::enter_onload_phase() { |
|
460 |
JvmtiEnvBase::set_phase(JVMTI_PHASE_ONLOAD); |
|
461 |
} |
|
462 |
||
463 |
void JvmtiExport::enter_live_phase() { |
|
464 |
JvmtiEnvBase::set_phase(JVMTI_PHASE_LIVE); |
|
465 |
} |
|
466 |
||
467 |
// |
|
468 |
// JVMTI events that the VM posts to the debugger and also startup agent |
|
469 |
// and call the agent's premain() for java.lang.instrument. |
|
470 |
// |
|
471 |
||
36508 | 472 |
void JvmtiExport::post_early_vm_start() { |
37992 | 473 |
EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("Trg Early VM start event triggered" )); |
36508 | 474 |
|
475 |
// can now enable some events |
|
476 |
JvmtiEventController::vm_start(); |
|
477 |
||
478 |
JvmtiEnvIterator it; |
|
479 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
480 |
// Only early vmstart envs post early VMStart event |
|
481 |
if (env->early_vmstart_env() && env->is_enabled(JVMTI_EVENT_VM_START)) { |
|
37992 | 482 |
EVT_TRACE(JVMTI_EVENT_VM_START, ("Evt Early VM start event sent" )); |
36508 | 483 |
JavaThread *thread = JavaThread::current(); |
484 |
JvmtiThreadEventMark jem(thread); |
|
485 |
JvmtiJavaThreadEventTransition jet(thread); |
|
486 |
jvmtiEventVMStart callback = env->callbacks()->VMStart; |
|
487 |
if (callback != NULL) { |
|
488 |
(*callback)(env->jvmti_external(), jem.jni_env()); |
|
489 |
} |
|
490 |
} |
|
491 |
} |
|
492 |
} |
|
493 |
||
1 | 494 |
void JvmtiExport::post_vm_start() { |
37992 | 495 |
EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("Trg VM start event triggered" )); |
1 | 496 |
|
497 |
// can now enable some events |
|
498 |
JvmtiEventController::vm_start(); |
|
499 |
||
500 |
JvmtiEnvIterator it; |
|
501 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
36508 | 502 |
// Early vmstart envs do not post normal VMStart event |
503 |
if (!env->early_vmstart_env() && env->is_enabled(JVMTI_EVENT_VM_START)) { |
|
37992 | 504 |
EVT_TRACE(JVMTI_EVENT_VM_START, ("Evt VM start event sent" )); |
1 | 505 |
|
506 |
JavaThread *thread = JavaThread::current(); |
|
507 |
JvmtiThreadEventMark jem(thread); |
|
508 |
JvmtiJavaThreadEventTransition jet(thread); |
|
509 |
jvmtiEventVMStart callback = env->callbacks()->VMStart; |
|
510 |
if (callback != NULL) { |
|
511 |
(*callback)(env->jvmti_external(), jem.jni_env()); |
|
512 |
} |
|
513 |
} |
|
514 |
} |
|
515 |
} |
|
516 |
||
517 |
||
518 |
void JvmtiExport::post_vm_initialized() { |
|
37992 | 519 |
EVT_TRIG_TRACE(JVMTI_EVENT_VM_INIT, ("Trg VM init event triggered" )); |
1 | 520 |
|
521 |
// can now enable events |
|
522 |
JvmtiEventController::vm_init(); |
|
523 |
||
524 |
JvmtiEnvIterator it; |
|
525 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
526 |
if (env->is_enabled(JVMTI_EVENT_VM_INIT)) { |
|
37992 | 527 |
EVT_TRACE(JVMTI_EVENT_VM_INIT, ("Evt VM init event sent" )); |
1 | 528 |
|
529 |
JavaThread *thread = JavaThread::current(); |
|
530 |
JvmtiThreadEventMark jem(thread); |
|
531 |
JvmtiJavaThreadEventTransition jet(thread); |
|
532 |
jvmtiEventVMInit callback = env->callbacks()->VMInit; |
|
533 |
if (callback != NULL) { |
|
534 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); |
|
535 |
} |
|
536 |
} |
|
537 |
} |
|
538 |
} |
|
539 |
||
540 |
||
541 |
void JvmtiExport::post_vm_death() { |
|
37992 | 542 |
EVT_TRIG_TRACE(JVMTI_EVENT_VM_DEATH, ("Trg VM death event triggered" )); |
1 | 543 |
|
544 |
JvmtiEnvIterator it; |
|
545 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
546 |
if (env->is_enabled(JVMTI_EVENT_VM_DEATH)) { |
|
37992 | 547 |
EVT_TRACE(JVMTI_EVENT_VM_DEATH, ("Evt VM death event sent" )); |
1 | 548 |
|
549 |
JavaThread *thread = JavaThread::current(); |
|
550 |
JvmtiEventMark jem(thread); |
|
551 |
JvmtiJavaThreadEventTransition jet(thread); |
|
552 |
jvmtiEventVMDeath callback = env->callbacks()->VMDeath; |
|
553 |
if (callback != NULL) { |
|
554 |
(*callback)(env->jvmti_external(), jem.jni_env()); |
|
555 |
} |
|
556 |
} |
|
557 |
} |
|
558 |
||
559 |
JvmtiEnvBase::set_phase(JVMTI_PHASE_DEAD); |
|
560 |
JvmtiEventController::vm_death(); |
|
561 |
} |
|
562 |
||
563 |
char** |
|
564 |
JvmtiExport::get_all_native_method_prefixes(int* count_ptr) { |
|
565 |
// Have to grab JVMTI thread state lock to be sure environment doesn't |
|
566 |
// go away while we iterate them. No locks during VM bring-up. |
|
567 |
if (Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint()) { |
|
568 |
return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr); |
|
569 |
} else { |
|
570 |
MutexLocker mu(JvmtiThreadState_lock); |
|
571 |
return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr); |
|
572 |
} |
|
573 |
} |
|
574 |
||
575 |
class JvmtiClassFileLoadHookPoster : public StackObj { |
|
576 |
private: |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7918
diff
changeset
|
577 |
Symbol* _h_name; |
1 | 578 |
Handle _class_loader; |
579 |
Handle _h_protection_domain; |
|
580 |
unsigned char ** _data_ptr; |
|
581 |
unsigned char ** _end_ptr; |
|
582 |
JavaThread * _thread; |
|
583 |
jint _curr_len; |
|
584 |
unsigned char * _curr_data; |
|
585 |
JvmtiEnv * _curr_env; |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
586 |
JvmtiCachedClassFileData ** _cached_class_file_ptr; |
1 | 587 |
JvmtiThreadState * _state; |
588 |
KlassHandle * _h_class_being_redefined; |
|
589 |
JvmtiClassLoadKind _load_kind; |
|
590 |
||
591 |
public: |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7918
diff
changeset
|
592 |
inline JvmtiClassFileLoadHookPoster(Symbol* h_name, Handle class_loader, |
1 | 593 |
Handle h_protection_domain, |
594 |
unsigned char **data_ptr, unsigned char **end_ptr, |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
595 |
JvmtiCachedClassFileData **cache_ptr) { |
1 | 596 |
_h_name = h_name; |
597 |
_class_loader = class_loader; |
|
598 |
_h_protection_domain = h_protection_domain; |
|
599 |
_data_ptr = data_ptr; |
|
600 |
_end_ptr = end_ptr; |
|
601 |
_thread = JavaThread::current(); |
|
602 |
_curr_len = *end_ptr - *data_ptr; |
|
603 |
_curr_data = *data_ptr; |
|
604 |
_curr_env = NULL; |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
605 |
_cached_class_file_ptr = cache_ptr; |
1 | 606 |
|
607 |
_state = _thread->jvmti_thread_state(); |
|
608 |
if (_state != NULL) { |
|
609 |
_h_class_being_redefined = _state->get_class_being_redefined(); |
|
610 |
_load_kind = _state->get_class_load_kind(); |
|
36508 | 611 |
Klass* klass = (_h_class_being_redefined == NULL) ? NULL : (*_h_class_being_redefined)(); |
612 |
if (_load_kind != jvmti_class_load_kind_load && klass != NULL) { |
|
613 |
ModuleEntry* module_entry = InstanceKlass::cast(klass)->module(); |
|
614 |
assert(module_entry != NULL, "module_entry should always be set"); |
|
615 |
if (module_entry->is_named() && |
|
616 |
module_entry->module() != NULL && |
|
617 |
!module_entry->has_default_read_edges()) { |
|
618 |
if (!module_entry->set_has_default_read_edges()) { |
|
619 |
// We won a potential race. |
|
620 |
// Add read edges to the unnamed modules of the bootstrap and app class loaders |
|
621 |
Handle class_module(_thread, JNIHandles::resolve(module_entry->module())); // Obtain j.l.r.Module |
|
622 |
JvmtiExport::add_default_read_edges(class_module, _thread); |
|
623 |
} |
|
624 |
} |
|
625 |
} |
|
1 | 626 |
// Clear class_being_redefined flag here. The action |
627 |
// from agent handler could generate a new class file load |
|
628 |
// hook event and if it is not cleared the new event generated |
|
629 |
// from regular class file load could have this stale redefined |
|
630 |
// class handle info. |
|
631 |
_state->clear_class_being_redefined(); |
|
632 |
} else { |
|
633 |
// redefine and retransform will always set the thread state |
|
634 |
_h_class_being_redefined = (KlassHandle *) NULL; |
|
635 |
_load_kind = jvmti_class_load_kind_load; |
|
636 |
} |
|
637 |
} |
|
638 |
||
639 |
void post() { |
|
640 |
post_all_envs(); |
|
641 |
copy_modified_data(); |
|
642 |
} |
|
643 |
||
644 |
private: |
|
645 |
void post_all_envs() { |
|
646 |
if (_load_kind != jvmti_class_load_kind_retransform) { |
|
647 |
// for class load and redefine, |
|
648 |
// call the non-retransformable agents |
|
649 |
JvmtiEnvIterator it; |
|
650 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
651 |
if (!env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) { |
|
652 |
// non-retransformable agents cannot retransform back, |
|
653 |
// so no need to cache the original class file bytes |
|
654 |
post_to_env(env, false); |
|
655 |
} |
|
656 |
} |
|
657 |
} |
|
658 |
JvmtiEnvIterator it; |
|
659 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
660 |
// retransformable agents get all events |
|
661 |
if (env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) { |
|
662 |
// retransformable agents need to cache the original class file |
|
663 |
// bytes if changes are made via the ClassFileLoadHook |
|
664 |
post_to_env(env, true); |
|
665 |
} |
|
666 |
} |
|
667 |
} |
|
668 |
||
669 |
void post_to_env(JvmtiEnv* env, bool caching_needed) { |
|
38110
22bb1ed67962
8153749: New capability can_generate_early_class_hook_events
sspitsyn
parents:
38060
diff
changeset
|
670 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL && !env->early_class_hook_env()) { |
36508 | 671 |
return; |
672 |
} |
|
1 | 673 |
unsigned char *new_data = NULL; |
674 |
jint new_len = 0; |
|
675 |
JvmtiClassFileLoadEventMark jem(_thread, _h_name, _class_loader, |
|
676 |
_h_protection_domain, |
|
677 |
_h_class_being_redefined); |
|
678 |
JvmtiJavaThreadEventTransition jet(_thread); |
|
679 |
jvmtiEventClassFileLoadHook callback = env->callbacks()->ClassFileLoadHook; |
|
680 |
if (callback != NULL) { |
|
36508 | 681 |
(*callback)(env->jvmti_external(), jem.jni_env(), |
1 | 682 |
jem.class_being_redefined(), |
683 |
jem.jloader(), jem.class_name(), |
|
684 |
jem.protection_domain(), |
|
685 |
_curr_len, _curr_data, |
|
686 |
&new_len, &new_data); |
|
687 |
} |
|
688 |
if (new_data != NULL) { |
|
689 |
// this agent has modified class data. |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
690 |
if (caching_needed && *_cached_class_file_ptr == NULL) { |
1 | 691 |
// data has been changed by the new retransformable agent |
692 |
// and it hasn't already been cached, cache it |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
693 |
JvmtiCachedClassFileData *p; |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
694 |
p = (JvmtiCachedClassFileData *)os::malloc( |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
695 |
offset_of(JvmtiCachedClassFileData, data) + _curr_len, mtInternal); |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
696 |
if (p == NULL) { |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
697 |
vm_exit_out_of_memory(offset_of(JvmtiCachedClassFileData, data) + _curr_len, |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
698 |
OOM_MALLOC_ERROR, |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
699 |
"unable to allocate cached copy of original class bytes"); |
17368
b7cb1739172e
8008255: jvmtiExport.cpp::post_to_env() does not check malloc() return
rbackman
parents:
15484
diff
changeset
|
700 |
} |
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
701 |
p->length = _curr_len; |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
702 |
memcpy(p->data, _curr_data, _curr_len); |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
703 |
*_cached_class_file_ptr = p; |
1 | 704 |
} |
705 |
||
706 |
if (_curr_data != *_data_ptr) { |
|
707 |
// curr_data is previous agent modified class data. |
|
708 |
// And this has been changed by the new agent so |
|
709 |
// we can delete it now. |
|
710 |
_curr_env->Deallocate(_curr_data); |
|
711 |
} |
|
712 |
||
713 |
// Class file data has changed by the current agent. |
|
714 |
_curr_data = new_data; |
|
715 |
_curr_len = new_len; |
|
716 |
// Save the current agent env we need this to deallocate the |
|
717 |
// memory allocated by this agent. |
|
718 |
_curr_env = env; |
|
719 |
} |
|
720 |
} |
|
721 |
||
722 |
void copy_modified_data() { |
|
723 |
// if one of the agent has modified class file data. |
|
724 |
// Copy modified class data to new resources array. |
|
725 |
if (_curr_data != *_data_ptr) { |
|
726 |
*_data_ptr = NEW_RESOURCE_ARRAY(u1, _curr_len); |
|
727 |
memcpy(*_data_ptr, _curr_data, _curr_len); |
|
728 |
*_end_ptr = *_data_ptr + _curr_len; |
|
729 |
_curr_env->Deallocate(_curr_data); |
|
730 |
} |
|
731 |
} |
|
732 |
}; |
|
733 |
||
734 |
bool JvmtiExport::_should_post_class_file_load_hook = false; |
|
735 |
||
736 |
// this entry is for class file load hook on class load, redefine and retransform |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7918
diff
changeset
|
737 |
void JvmtiExport::post_class_file_load_hook(Symbol* h_name, |
1 | 738 |
Handle class_loader, |
739 |
Handle h_protection_domain, |
|
740 |
unsigned char **data_ptr, |
|
741 |
unsigned char **end_ptr, |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
742 |
JvmtiCachedClassFileData **cache_ptr) { |
36508 | 743 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
744 |
return; |
|
745 |
} |
|
746 |
||
1 | 747 |
JvmtiClassFileLoadHookPoster poster(h_name, class_loader, |
748 |
h_protection_domain, |
|
749 |
data_ptr, end_ptr, |
|
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
17597
diff
changeset
|
750 |
cache_ptr); |
1 | 751 |
poster.post(); |
752 |
} |
|
753 |
||
754 |
void JvmtiExport::report_unsupported(bool on) { |
|
755 |
// If any JVMTI service is turned on, we need to exit before native code |
|
756 |
// tries to access nonexistant services. |
|
757 |
if (on) { |
|
758 |
vm_exit_during_initialization("Java Kernel does not support JVMTI."); |
|
759 |
} |
|
760 |
} |
|
761 |
||
762 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
763 |
static inline Klass* oop_to_klass(oop obj) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
764 |
Klass* k = obj->klass(); |
1 | 765 |
|
766 |
// if the object is a java.lang.Class then return the java mirror |
|
4571 | 767 |
if (k == SystemDictionary::Class_klass()) { |
1 | 768 |
if (!java_lang_Class::is_primitive(obj)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
769 |
k = java_lang_Class::as_Klass(obj); |
1 | 770 |
assert(k != NULL, "class for non-primitive mirror must exist"); |
771 |
} |
|
772 |
} |
|
773 |
return k; |
|
774 |
} |
|
775 |
||
776 |
class JvmtiVMObjectAllocEventMark : public JvmtiClassEventMark { |
|
777 |
private: |
|
778 |
jobject _jobj; |
|
779 |
jlong _size; |
|
780 |
public: |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
781 |
JvmtiVMObjectAllocEventMark(JavaThread *thread, oop obj) : JvmtiClassEventMark(thread, oop_to_klass(obj)) { |
1 | 782 |
_jobj = (jobject)to_jobject(obj); |
783 |
_size = obj->size() * wordSize; |
|
784 |
}; |
|
785 |
jobject jni_jobject() { return _jobj; } |
|
786 |
jlong size() { return _size; } |
|
787 |
}; |
|
788 |
||
789 |
class JvmtiCompiledMethodLoadEventMark : public JvmtiMethodEventMark { |
|
790 |
private: |
|
791 |
jint _code_size; |
|
792 |
const void *_code_data; |
|
793 |
jint _map_length; |
|
794 |
jvmtiAddrLocationMap *_map; |
|
795 |
const void *_compile_info; |
|
796 |
public: |
|
4732
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
797 |
JvmtiCompiledMethodLoadEventMark(JavaThread *thread, nmethod *nm, void* compile_info_ptr = NULL) |
1 | 798 |
: JvmtiMethodEventMark(thread,methodHandle(thread, nm->method())) { |
6418 | 799 |
_code_data = nm->insts_begin(); |
800 |
_code_size = nm->insts_size(); |
|
4732
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
801 |
_compile_info = compile_info_ptr; // Set void pointer of compiledMethodLoad Event. Default value is NULL. |
1 | 802 |
JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nm, &_map, &_map_length); |
803 |
} |
|
804 |
~JvmtiCompiledMethodLoadEventMark() { |
|
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
25468
diff
changeset
|
805 |
FREE_C_HEAP_ARRAY(jvmtiAddrLocationMap, _map); |
1 | 806 |
} |
807 |
||
808 |
jint code_size() { return _code_size; } |
|
809 |
const void *code_data() { return _code_data; } |
|
810 |
jint map_length() { return _map_length; } |
|
811 |
const jvmtiAddrLocationMap* map() { return _map; } |
|
812 |
const void *compile_info() { return _compile_info; } |
|
813 |
}; |
|
814 |
||
815 |
||
816 |
||
817 |
class JvmtiMonitorEventMark : public JvmtiThreadEventMark { |
|
818 |
private: |
|
819 |
jobject _jobj; |
|
820 |
public: |
|
821 |
JvmtiMonitorEventMark(JavaThread *thread, oop object) |
|
822 |
: JvmtiThreadEventMark(thread){ |
|
823 |
_jobj = to_jobject(object); |
|
824 |
} |
|
825 |
jobject jni_object() { return _jobj; } |
|
826 |
}; |
|
827 |
||
828 |
/////////////////////////////////////////////////////////////// |
|
829 |
// |
|
830 |
// pending CompiledMethodUnload support |
|
831 |
// |
|
832 |
||
8110
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
833 |
void JvmtiExport::post_compiled_method_unload( |
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
834 |
jmethodID method, const void *code_begin) { |
36508 | 835 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
836 |
return; |
|
837 |
} |
|
8110
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
838 |
JavaThread* thread = JavaThread::current(); |
5700
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
839 |
EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_UNLOAD, |
37992 | 840 |
("[%s] method compile unload event triggered", |
8110
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
841 |
JvmtiTrace::safe_get_thread_name(thread))); |
5700
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
842 |
|
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
843 |
// post the event for each environment that has this event enabled. |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
844 |
JvmtiEnvIterator it; |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
845 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
846 |
if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_UNLOAD)) { |
36508 | 847 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
848 |
continue; |
|
849 |
} |
|
5700
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
850 |
EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_UNLOAD, |
37992 | 851 |
("[%s] class compile method unload event sent jmethodID " PTR_FORMAT, |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
32817
diff
changeset
|
852 |
JvmtiTrace::safe_get_thread_name(thread), p2i(method))); |
5700
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
853 |
|
8110
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
854 |
ResourceMark rm(thread); |
5700
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
855 |
|
8110
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
856 |
JvmtiEventMark jem(thread); |
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
857 |
JvmtiJavaThreadEventTransition jet(thread); |
5700
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
858 |
jvmtiEventCompiledMethodUnload callback = env->callbacks()->CompiledMethodUnload; |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
859 |
if (callback != NULL) { |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
860 |
(*callback)(env->jvmti_external(), method, code_begin); |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
861 |
} |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
862 |
} |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
863 |
} |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
864 |
} |
a78767273dc1
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
5353
diff
changeset
|
865 |
|
1 | 866 |
/////////////////////////////////////////////////////////////// |
867 |
// |
|
868 |
// JvmtiExport |
|
869 |
// |
|
870 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
871 |
void JvmtiExport::post_raw_breakpoint(JavaThread *thread, Method* method, address location) { |
1 | 872 |
HandleMark hm(thread); |
873 |
methodHandle mh(thread, method); |
|
874 |
||
875 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
876 |
if (state == NULL) { |
|
877 |
return; |
|
878 |
} |
|
37992 | 879 |
EVT_TRIG_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Trg Breakpoint triggered", |
1 | 880 |
JvmtiTrace::safe_get_thread_name(thread))); |
881 |
JvmtiEnvThreadStateIterator it(state); |
|
882 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
883 |
ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_BREAKPOINT); |
|
884 |
if (!ets->breakpoint_posted() && ets->is_enabled(JVMTI_EVENT_BREAKPOINT)) { |
|
885 |
ThreadState old_os_state = thread->osthread()->get_state(); |
|
886 |
thread->osthread()->set_state(BREAKPOINTED); |
|
37992 | 887 |
EVT_TRACE(JVMTI_EVENT_BREAKPOINT, ("[%s] Evt Breakpoint sent %s.%s @ " INTX_FORMAT, |
1 | 888 |
JvmtiTrace::safe_get_thread_name(thread), |
889 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
890 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
891 |
location - mh()->code_base() )); |
|
892 |
||
893 |
JvmtiEnv *env = ets->get_env(); |
|
894 |
JvmtiLocationEventMark jem(thread, mh, location); |
|
895 |
JvmtiJavaThreadEventTransition jet(thread); |
|
896 |
jvmtiEventBreakpoint callback = env->callbacks()->Breakpoint; |
|
897 |
if (callback != NULL) { |
|
898 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
899 |
jem.jni_methodID(), jem.location()); |
|
900 |
} |
|
901 |
||
902 |
ets->set_breakpoint_posted(); |
|
903 |
thread->osthread()->set_state(old_os_state); |
|
904 |
} |
|
905 |
} |
|
906 |
} |
|
907 |
||
908 |
////////////////////////////////////////////////////////////////////////////// |
|
909 |
||
910 |
bool JvmtiExport::_can_get_source_debug_extension = false; |
|
911 |
bool JvmtiExport::_can_maintain_original_method_order = false; |
|
912 |
bool JvmtiExport::_can_post_interpreter_events = false; |
|
4761
bdb7375a1fee
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
4733
diff
changeset
|
913 |
bool JvmtiExport::_can_post_on_exceptions = false; |
1 | 914 |
bool JvmtiExport::_can_post_breakpoint = false; |
915 |
bool JvmtiExport::_can_post_field_access = false; |
|
916 |
bool JvmtiExport::_can_post_field_modification = false; |
|
917 |
bool JvmtiExport::_can_post_method_entry = false; |
|
918 |
bool JvmtiExport::_can_post_method_exit = false; |
|
919 |
bool JvmtiExport::_can_pop_frame = false; |
|
920 |
bool JvmtiExport::_can_force_early_return = false; |
|
921 |
||
36508 | 922 |
bool JvmtiExport::_early_vmstart_recorded = false; |
923 |
||
1 | 924 |
bool JvmtiExport::_should_post_single_step = false; |
925 |
bool JvmtiExport::_should_post_field_access = false; |
|
926 |
bool JvmtiExport::_should_post_field_modification = false; |
|
927 |
bool JvmtiExport::_should_post_class_load = false; |
|
928 |
bool JvmtiExport::_should_post_class_prepare = false; |
|
929 |
bool JvmtiExport::_should_post_class_unload = false; |
|
930 |
bool JvmtiExport::_should_post_thread_life = false; |
|
931 |
bool JvmtiExport::_should_clean_up_heap_objects = false; |
|
932 |
bool JvmtiExport::_should_post_native_method_bind = false; |
|
933 |
bool JvmtiExport::_should_post_dynamic_code_generated = false; |
|
934 |
bool JvmtiExport::_should_post_data_dump = false; |
|
935 |
bool JvmtiExport::_should_post_compiled_method_load = false; |
|
936 |
bool JvmtiExport::_should_post_compiled_method_unload = false; |
|
937 |
bool JvmtiExport::_should_post_monitor_contended_enter = false; |
|
938 |
bool JvmtiExport::_should_post_monitor_contended_entered = false; |
|
939 |
bool JvmtiExport::_should_post_monitor_wait = false; |
|
940 |
bool JvmtiExport::_should_post_monitor_waited = false; |
|
941 |
bool JvmtiExport::_should_post_garbage_collection_start = false; |
|
942 |
bool JvmtiExport::_should_post_garbage_collection_finish = false; |
|
943 |
bool JvmtiExport::_should_post_object_free = false; |
|
944 |
bool JvmtiExport::_should_post_resource_exhausted = false; |
|
945 |
bool JvmtiExport::_should_post_vm_object_alloc = false; |
|
4761
bdb7375a1fee
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
4733
diff
changeset
|
946 |
bool JvmtiExport::_should_post_on_exceptions = false; |
1 | 947 |
|
948 |
//////////////////////////////////////////////////////////////////////////////////////////////// |
|
949 |
||
950 |
||
951 |
// |
|
952 |
// JVMTI single step management |
|
953 |
// |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
954 |
void JvmtiExport::at_single_stepping_point(JavaThread *thread, Method* method, address location) { |
1 | 955 |
assert(JvmtiExport::should_post_single_step(), "must be single stepping"); |
956 |
||
957 |
HandleMark hm(thread); |
|
958 |
methodHandle mh(thread, method); |
|
959 |
||
960 |
// update information about current location and post a step event |
|
961 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
962 |
if (state == NULL) { |
|
963 |
return; |
|
964 |
} |
|
37992 | 965 |
EVT_TRIG_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Trg Single Step triggered", |
1 | 966 |
JvmtiTrace::safe_get_thread_name(thread))); |
967 |
if (!state->hide_single_stepping()) { |
|
968 |
if (state->is_pending_step_for_popframe()) { |
|
969 |
state->process_pending_step_for_popframe(); |
|
970 |
} |
|
971 |
if (state->is_pending_step_for_earlyret()) { |
|
972 |
state->process_pending_step_for_earlyret(); |
|
973 |
} |
|
974 |
JvmtiExport::post_single_step(thread, mh(), location); |
|
975 |
} |
|
976 |
} |
|
977 |
||
978 |
||
979 |
void JvmtiExport::expose_single_stepping(JavaThread *thread) { |
|
980 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
981 |
if (state != NULL) { |
|
982 |
state->clear_hide_single_stepping(); |
|
983 |
} |
|
984 |
} |
|
985 |
||
986 |
||
987 |
bool JvmtiExport::hide_single_stepping(JavaThread *thread) { |
|
988 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
989 |
if (state != NULL && state->is_enabled(JVMTI_EVENT_SINGLE_STEP)) { |
|
990 |
state->set_hide_single_stepping(); |
|
991 |
return true; |
|
992 |
} else { |
|
993 |
return false; |
|
994 |
} |
|
995 |
} |
|
996 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
997 |
void JvmtiExport::post_class_load(JavaThread *thread, Klass* klass) { |
36508 | 998 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
999 |
return; |
|
1000 |
} |
|
1 | 1001 |
HandleMark hm(thread); |
1002 |
KlassHandle kh(thread, klass); |
|
1003 |
||
37992 | 1004 |
EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_LOAD, ("[%s] Trg Class Load triggered", |
1 | 1005 |
JvmtiTrace::safe_get_thread_name(thread))); |
1006 |
JvmtiThreadState* state = thread->jvmti_thread_state(); |
|
1007 |
if (state == NULL) { |
|
1008 |
return; |
|
1009 |
} |
|
1010 |
JvmtiEnvThreadStateIterator it(state); |
|
1011 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1012 |
if (ets->is_enabled(JVMTI_EVENT_CLASS_LOAD)) { |
|
36508 | 1013 |
JvmtiEnv *env = ets->get_env(); |
1014 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
|
1015 |
continue; |
|
1016 |
} |
|
37992 | 1017 |
EVT_TRACE(JVMTI_EVENT_CLASS_LOAD, ("[%s] Evt Class Load sent %s", |
1 | 1018 |
JvmtiTrace::safe_get_thread_name(thread), |
14488 | 1019 |
kh()==NULL? "NULL" : kh()->external_name() )); |
1 | 1020 |
JvmtiClassEventMark jem(thread, kh()); |
1021 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1022 |
jvmtiEventClassLoad callback = env->callbacks()->ClassLoad; |
|
1023 |
if (callback != NULL) { |
|
1024 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_class()); |
|
1025 |
} |
|
1026 |
} |
|
1027 |
} |
|
1028 |
} |
|
1029 |
||
1030 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1031 |
void JvmtiExport::post_class_prepare(JavaThread *thread, Klass* klass) { |
36508 | 1032 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
1033 |
return; |
|
1034 |
} |
|
1 | 1035 |
HandleMark hm(thread); |
1036 |
KlassHandle kh(thread, klass); |
|
1037 |
||
37992 | 1038 |
EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("[%s] Trg Class Prepare triggered", |
1 | 1039 |
JvmtiTrace::safe_get_thread_name(thread))); |
1040 |
JvmtiThreadState* state = thread->jvmti_thread_state(); |
|
1041 |
if (state == NULL) { |
|
1042 |
return; |
|
1043 |
} |
|
1044 |
JvmtiEnvThreadStateIterator it(state); |
|
1045 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1046 |
if (ets->is_enabled(JVMTI_EVENT_CLASS_PREPARE)) { |
|
36508 | 1047 |
JvmtiEnv *env = ets->get_env(); |
1048 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
|
1049 |
continue; |
|
1050 |
} |
|
37992 | 1051 |
EVT_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("[%s] Evt Class Prepare sent %s", |
1 | 1052 |
JvmtiTrace::safe_get_thread_name(thread), |
14488 | 1053 |
kh()==NULL? "NULL" : kh()->external_name() )); |
1 | 1054 |
JvmtiClassEventMark jem(thread, kh()); |
1055 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1056 |
jvmtiEventClassPrepare callback = env->callbacks()->ClassPrepare; |
|
1057 |
if (callback != NULL) { |
|
1058 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_class()); |
|
1059 |
} |
|
1060 |
} |
|
1061 |
} |
|
1062 |
} |
|
1063 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1064 |
void JvmtiExport::post_class_unload(Klass* klass) { |
36508 | 1065 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
1066 |
return; |
|
1067 |
} |
|
1 | 1068 |
Thread *thread = Thread::current(); |
1069 |
HandleMark hm(thread); |
|
1070 |
KlassHandle kh(thread, klass); |
|
1071 |
||
37992 | 1072 |
EVT_TRIG_TRACE(EXT_EVENT_CLASS_UNLOAD, ("[?] Trg Class Unload triggered" )); |
1 | 1073 |
if (JvmtiEventController::is_enabled((jvmtiEvent)EXT_EVENT_CLASS_UNLOAD)) { |
1074 |
assert(thread->is_VM_thread(), "wrong thread"); |
|
1075 |
||
1076 |
// get JavaThread for whom we are proxy |
|
1077 |
JavaThread *real_thread = |
|
1078 |
(JavaThread *)((VMThread *)thread)->vm_operation()->calling_thread(); |
|
1079 |
||
1080 |
JvmtiEnvIterator it; |
|
1081 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
36508 | 1082 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
1083 |
continue; |
|
1084 |
} |
|
1 | 1085 |
if (env->is_enabled((jvmtiEvent)EXT_EVENT_CLASS_UNLOAD)) { |
37992 | 1086 |
EVT_TRACE(EXT_EVENT_CLASS_UNLOAD, ("[?] Evt Class Unload sent %s", |
14488 | 1087 |
kh()==NULL? "NULL" : kh()->external_name() )); |
1 | 1088 |
|
1089 |
// do everything manually, since this is a proxy - needs special care |
|
1090 |
JNIEnv* jni_env = real_thread->jni_environment(); |
|
1091 |
jthread jt = (jthread)JNIHandles::make_local(real_thread, real_thread->threadObj()); |
|
14488 | 1092 |
jclass jk = (jclass)JNIHandles::make_local(real_thread, kh()->java_mirror()); |
1 | 1093 |
|
1094 |
// Before we call the JVMTI agent, we have to set the state in the |
|
1095 |
// thread for which we are proxying. |
|
1096 |
JavaThreadState prev_state = real_thread->thread_state(); |
|
23447 | 1097 |
assert(((Thread *)real_thread)->is_ConcurrentGC_thread() || |
1098 |
(real_thread->is_Java_thread() && prev_state == _thread_blocked), |
|
1099 |
"should be ConcurrentGCThread or JavaThread at safepoint"); |
|
1 | 1100 |
real_thread->set_thread_state(_thread_in_native); |
1101 |
||
1102 |
jvmtiExtensionEvent callback = env->ext_callbacks()->ClassUnload; |
|
1103 |
if (callback != NULL) { |
|
1104 |
(*callback)(env->jvmti_external(), jni_env, jt, jk); |
|
1105 |
} |
|
1106 |
||
1107 |
assert(real_thread->thread_state() == _thread_in_native, |
|
1108 |
"JavaThread should be in native"); |
|
1109 |
real_thread->set_thread_state(prev_state); |
|
1110 |
||
1111 |
JNIHandles::destroy_local(jk); |
|
1112 |
JNIHandles::destroy_local(jt); |
|
1113 |
} |
|
1114 |
} |
|
1115 |
} |
|
1116 |
} |
|
1117 |
||
1118 |
||
1119 |
void JvmtiExport::post_thread_start(JavaThread *thread) { |
|
36508 | 1120 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
1121 |
return; |
|
1122 |
} |
|
1 | 1123 |
assert(thread->thread_state() == _thread_in_vm, "must be in vm state"); |
1124 |
||
37992 | 1125 |
EVT_TRIG_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Trg Thread Start event triggered", |
1 | 1126 |
JvmtiTrace::safe_get_thread_name(thread))); |
1127 |
||
1128 |
// do JVMTI thread initialization (if needed) |
|
1129 |
JvmtiEventController::thread_started(thread); |
|
1130 |
||
1131 |
// Do not post thread start event for hidden java thread. |
|
1132 |
if (JvmtiEventController::is_enabled(JVMTI_EVENT_THREAD_START) && |
|
1133 |
!thread->is_hidden_from_external_view()) { |
|
1134 |
JvmtiEnvIterator it; |
|
1135 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
36508 | 1136 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
1137 |
continue; |
|
1138 |
} |
|
1 | 1139 |
if (env->is_enabled(JVMTI_EVENT_THREAD_START)) { |
37992 | 1140 |
EVT_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Evt Thread Start event sent", |
1 | 1141 |
JvmtiTrace::safe_get_thread_name(thread) )); |
1142 |
||
1143 |
JvmtiThreadEventMark jem(thread); |
|
1144 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1145 |
jvmtiEventThreadStart callback = env->callbacks()->ThreadStart; |
|
1146 |
if (callback != NULL) { |
|
1147 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); |
|
1148 |
} |
|
1149 |
} |
|
1150 |
} |
|
1151 |
} |
|
1152 |
} |
|
1153 |
||
1154 |
||
1155 |
void JvmtiExport::post_thread_end(JavaThread *thread) { |
|
36508 | 1156 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
1157 |
return; |
|
1158 |
} |
|
37992 | 1159 |
EVT_TRIG_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Trg Thread End event triggered", |
1 | 1160 |
JvmtiTrace::safe_get_thread_name(thread))); |
1161 |
||
1162 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1163 |
if (state == NULL) { |
|
1164 |
return; |
|
1165 |
} |
|
1166 |
||
1167 |
// Do not post thread end event for hidden java thread. |
|
1168 |
if (state->is_enabled(JVMTI_EVENT_THREAD_END) && |
|
1169 |
!thread->is_hidden_from_external_view()) { |
|
1170 |
||
1171 |
JvmtiEnvThreadStateIterator it(state); |
|
1172 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1173 |
if (ets->is_enabled(JVMTI_EVENT_THREAD_END)) { |
|
36508 | 1174 |
JvmtiEnv *env = ets->get_env(); |
1175 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
|
1176 |
continue; |
|
1177 |
} |
|
37992 | 1178 |
EVT_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Evt Thread End event sent", |
1 | 1179 |
JvmtiTrace::safe_get_thread_name(thread) )); |
1180 |
||
1181 |
JvmtiThreadEventMark jem(thread); |
|
1182 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1183 |
jvmtiEventThreadEnd callback = env->callbacks()->ThreadEnd; |
|
1184 |
if (callback != NULL) { |
|
1185 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread()); |
|
1186 |
} |
|
1187 |
} |
|
1188 |
} |
|
1189 |
} |
|
1190 |
} |
|
1191 |
||
1192 |
void JvmtiExport::post_object_free(JvmtiEnv* env, jlong tag) { |
|
1193 |
assert(SafepointSynchronize::is_at_safepoint(), "must be executed at safepoint"); |
|
1194 |
assert(env->is_enabled(JVMTI_EVENT_OBJECT_FREE), "checking"); |
|
1195 |
||
37992 | 1196 |
EVT_TRIG_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Trg Object Free triggered" )); |
1197 |
EVT_TRACE(JVMTI_EVENT_OBJECT_FREE, ("[?] Evt Object Free sent")); |
|
1 | 1198 |
|
1199 |
jvmtiEventObjectFree callback = env->callbacks()->ObjectFree; |
|
1200 |
if (callback != NULL) { |
|
1201 |
(*callback)(env->jvmti_external(), tag); |
|
1202 |
} |
|
1203 |
} |
|
1204 |
||
1205 |
void JvmtiExport::post_resource_exhausted(jint resource_exhausted_flags, const char* description) { |
|
37992 | 1206 |
EVT_TRIG_TRACE(JVMTI_EVENT_RESOURCE_EXHAUSTED, ("Trg resource exhausted event triggered" )); |
1 | 1207 |
|
1208 |
JvmtiEnvIterator it; |
|
1209 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
1210 |
if (env->is_enabled(JVMTI_EVENT_RESOURCE_EXHAUSTED)) { |
|
37992 | 1211 |
EVT_TRACE(JVMTI_EVENT_RESOURCE_EXHAUSTED, ("Evt resource exhausted event sent" )); |
1 | 1212 |
|
1213 |
JavaThread *thread = JavaThread::current(); |
|
1214 |
JvmtiThreadEventMark jem(thread); |
|
1215 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1216 |
jvmtiEventResourceExhausted callback = env->callbacks()->ResourceExhausted; |
|
1217 |
if (callback != NULL) { |
|
1218 |
(*callback)(env->jvmti_external(), jem.jni_env(), |
|
1219 |
resource_exhausted_flags, NULL, description); |
|
1220 |
} |
|
1221 |
} |
|
1222 |
} |
|
1223 |
} |
|
1224 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1225 |
void JvmtiExport::post_method_entry(JavaThread *thread, Method* method, frame current_frame) { |
1 | 1226 |
HandleMark hm(thread); |
1227 |
methodHandle mh(thread, method); |
|
1228 |
||
37992 | 1229 |
EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("[%s] Trg Method Entry triggered %s.%s", |
1 | 1230 |
JvmtiTrace::safe_get_thread_name(thread), |
1231 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1232 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string() )); |
|
1233 |
||
1234 |
JvmtiThreadState* state = thread->jvmti_thread_state(); |
|
1235 |
if (state == NULL || !state->is_interp_only_mode()) { |
|
1236 |
// for any thread that actually wants method entry, interp_only_mode is set |
|
1237 |
return; |
|
1238 |
} |
|
1239 |
||
1240 |
state->incr_cur_stack_depth(); |
|
1241 |
||
1242 |
if (state->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) { |
|
1243 |
JvmtiEnvThreadStateIterator it(state); |
|
1244 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1245 |
if (ets->is_enabled(JVMTI_EVENT_METHOD_ENTRY)) { |
|
37992 | 1246 |
EVT_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("[%s] Evt Method Entry sent %s.%s", |
1 | 1247 |
JvmtiTrace::safe_get_thread_name(thread), |
1248 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1249 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string() )); |
|
1250 |
||
1251 |
JvmtiEnv *env = ets->get_env(); |
|
1252 |
JvmtiMethodEventMark jem(thread, mh); |
|
1253 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1254 |
jvmtiEventMethodEntry callback = env->callbacks()->MethodEntry; |
|
1255 |
if (callback != NULL) { |
|
1256 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_methodID()); |
|
1257 |
} |
|
1258 |
} |
|
1259 |
} |
|
1260 |
} |
|
1261 |
} |
|
1262 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1263 |
void JvmtiExport::post_method_exit(JavaThread *thread, Method* method, frame current_frame) { |
1 | 1264 |
HandleMark hm(thread); |
1265 |
methodHandle mh(thread, method); |
|
1266 |
||
37992 | 1267 |
EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_EXIT, ("[%s] Trg Method Exit triggered %s.%s", |
1 | 1268 |
JvmtiTrace::safe_get_thread_name(thread), |
1269 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1270 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string() )); |
|
1271 |
||
1272 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1273 |
if (state == NULL || !state->is_interp_only_mode()) { |
|
1274 |
// for any thread that actually wants method exit, interp_only_mode is set |
|
1275 |
return; |
|
1276 |
} |
|
1277 |
||
1278 |
// return a flag when a method terminates by throwing an exception |
|
1279 |
// i.e. if an exception is thrown and it's not caught by the current method |
|
1280 |
bool exception_exit = state->is_exception_detected() && !state->is_exception_caught(); |
|
1281 |
||
1282 |
||
1283 |
if (state->is_enabled(JVMTI_EVENT_METHOD_EXIT)) { |
|
1284 |
Handle result; |
|
1285 |
jvalue value; |
|
1286 |
value.j = 0L; |
|
1287 |
||
1288 |
// if the method hasn't been popped because of an exception then we populate |
|
1289 |
// the return_value parameter for the callback. At this point we only have |
|
1290 |
// the address of a "raw result" and we just call into the interpreter to |
|
1291 |
// convert this into a jvalue. |
|
1292 |
if (!exception_exit) { |
|
1293 |
oop oop_result; |
|
1294 |
BasicType type = current_frame.interpreter_frame_result(&oop_result, &value); |
|
1295 |
if (type == T_OBJECT || type == T_ARRAY) { |
|
1296 |
result = Handle(thread, oop_result); |
|
1297 |
} |
|
1298 |
} |
|
1299 |
||
1300 |
JvmtiEnvThreadStateIterator it(state); |
|
1301 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1302 |
if (ets->is_enabled(JVMTI_EVENT_METHOD_EXIT)) { |
|
37992 | 1303 |
EVT_TRACE(JVMTI_EVENT_METHOD_EXIT, ("[%s] Evt Method Exit sent %s.%s", |
1 | 1304 |
JvmtiTrace::safe_get_thread_name(thread), |
1305 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1306 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string() )); |
|
1307 |
||
1308 |
JvmtiEnv *env = ets->get_env(); |
|
1309 |
JvmtiMethodEventMark jem(thread, mh); |
|
1310 |
if (result.not_null()) { |
|
1311 |
value.l = JNIHandles::make_local(thread, result()); |
|
1312 |
} |
|
1313 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1314 |
jvmtiEventMethodExit callback = env->callbacks()->MethodExit; |
|
1315 |
if (callback != NULL) { |
|
1316 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1317 |
jem.jni_methodID(), exception_exit, value); |
|
1318 |
} |
|
1319 |
} |
|
1320 |
} |
|
1321 |
} |
|
1322 |
||
1323 |
if (state->is_enabled(JVMTI_EVENT_FRAME_POP)) { |
|
1324 |
JvmtiEnvThreadStateIterator it(state); |
|
1325 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1326 |
int cur_frame_number = state->cur_stack_depth(); |
|
1327 |
||
1328 |
if (ets->is_frame_pop(cur_frame_number)) { |
|
1329 |
// we have a NotifyFramePop entry for this frame. |
|
1330 |
// now check that this env/thread wants this event |
|
1331 |
if (ets->is_enabled(JVMTI_EVENT_FRAME_POP)) { |
|
37992 | 1332 |
EVT_TRACE(JVMTI_EVENT_FRAME_POP, ("[%s] Evt Frame Pop sent %s.%s", |
1 | 1333 |
JvmtiTrace::safe_get_thread_name(thread), |
1334 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1335 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string() )); |
|
1336 |
||
1337 |
// we also need to issue a frame pop event for this frame |
|
1338 |
JvmtiEnv *env = ets->get_env(); |
|
1339 |
JvmtiMethodEventMark jem(thread, mh); |
|
1340 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1341 |
jvmtiEventFramePop callback = env->callbacks()->FramePop; |
|
1342 |
if (callback != NULL) { |
|
1343 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1344 |
jem.jni_methodID(), exception_exit); |
|
1345 |
} |
|
1346 |
} |
|
1347 |
// remove the frame's entry |
|
1348 |
ets->clear_frame_pop(cur_frame_number); |
|
1349 |
} |
|
1350 |
} |
|
1351 |
} |
|
1352 |
||
1353 |
state->decr_cur_stack_depth(); |
|
1354 |
} |
|
1355 |
||
1356 |
||
1357 |
// Todo: inline this for optimization |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1358 |
void JvmtiExport::post_single_step(JavaThread *thread, Method* method, address location) { |
1 | 1359 |
HandleMark hm(thread); |
1360 |
methodHandle mh(thread, method); |
|
1361 |
||
1362 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1363 |
if (state == NULL) { |
|
1364 |
return; |
|
1365 |
} |
|
1366 |
JvmtiEnvThreadStateIterator it(state); |
|
1367 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1368 |
ets->compare_and_set_current_location(mh(), location, JVMTI_EVENT_SINGLE_STEP); |
|
1369 |
if (!ets->single_stepping_posted() && ets->is_enabled(JVMTI_EVENT_SINGLE_STEP)) { |
|
37992 | 1370 |
EVT_TRACE(JVMTI_EVENT_SINGLE_STEP, ("[%s] Evt Single Step sent %s.%s @ " INTX_FORMAT, |
1 | 1371 |
JvmtiTrace::safe_get_thread_name(thread), |
1372 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1373 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
1374 |
location - mh()->code_base() )); |
|
1375 |
||
1376 |
JvmtiEnv *env = ets->get_env(); |
|
1377 |
JvmtiLocationEventMark jem(thread, mh, location); |
|
1378 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1379 |
jvmtiEventSingleStep callback = env->callbacks()->SingleStep; |
|
1380 |
if (callback != NULL) { |
|
1381 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1382 |
jem.jni_methodID(), jem.location()); |
|
1383 |
} |
|
1384 |
||
1385 |
ets->set_single_stepping_posted(); |
|
1386 |
} |
|
1387 |
} |
|
1388 |
} |
|
1389 |
||
1390 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1391 |
void JvmtiExport::post_exception_throw(JavaThread *thread, Method* method, address location, oop exception) { |
1 | 1392 |
HandleMark hm(thread); |
1393 |
methodHandle mh(thread, method); |
|
1394 |
Handle exception_handle(thread, exception); |
|
1395 |
||
1396 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1397 |
if (state == NULL) { |
|
1398 |
return; |
|
1399 |
} |
|
1400 |
||
37992 | 1401 |
EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION, ("[%s] Trg Exception thrown triggered", |
1 | 1402 |
JvmtiTrace::safe_get_thread_name(thread))); |
1403 |
if (!state->is_exception_detected()) { |
|
1404 |
state->set_exception_detected(); |
|
1405 |
JvmtiEnvThreadStateIterator it(state); |
|
1406 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1407 |
if (ets->is_enabled(JVMTI_EVENT_EXCEPTION) && (exception != NULL)) { |
|
1408 |
||
1409 |
EVT_TRACE(JVMTI_EVENT_EXCEPTION, |
|
37992 | 1410 |
("[%s] Evt Exception thrown sent %s.%s @ " INTX_FORMAT, |
1 | 1411 |
JvmtiTrace::safe_get_thread_name(thread), |
1412 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1413 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
1414 |
location - mh()->code_base() )); |
|
1415 |
||
1416 |
JvmtiEnv *env = ets->get_env(); |
|
1417 |
JvmtiExceptionEventMark jem(thread, mh, location, exception_handle); |
|
1418 |
||
1419 |
// It's okay to clear these exceptions here because we duplicate |
|
1420 |
// this lookup in InterpreterRuntime::exception_handler_for_exception. |
|
1421 |
EXCEPTION_MARK; |
|
1422 |
||
1423 |
bool should_repeat; |
|
1424 |
vframeStream st(thread); |
|
1425 |
assert(!st.at_end(), "cannot be at end"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1426 |
Method* current_method = NULL; |
15109
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1427 |
// A GC may occur during the Method::fast_exception_handler_bci_for() |
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1428 |
// call below if it needs to load the constraint class. Using a |
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1429 |
// methodHandle to keep the 'current_method' from being deallocated |
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1430 |
// if GC happens. |
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1431 |
methodHandle current_mh = methodHandle(thread, current_method); |
1 | 1432 |
int current_bci = -1; |
1433 |
do { |
|
1434 |
current_method = st.method(); |
|
15109
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1435 |
current_mh = methodHandle(thread, current_method); |
1 | 1436 |
current_bci = st.bci(); |
1437 |
do { |
|
1438 |
should_repeat = false; |
|
1439 |
KlassHandle eh_klass(thread, exception_handle()->klass()); |
|
15109
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1440 |
current_bci = Method::fast_exception_handler_bci_for( |
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1441 |
current_mh, eh_klass, current_bci, THREAD); |
1 | 1442 |
if (HAS_PENDING_EXCEPTION) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1443 |
exception_handle = Handle(thread, PENDING_EXCEPTION); |
1 | 1444 |
CLEAR_PENDING_EXCEPTION; |
1445 |
should_repeat = true; |
|
1446 |
} |
|
1447 |
} while (should_repeat && (current_bci != -1)); |
|
1448 |
st.next(); |
|
1449 |
} while ((current_bci < 0) && (!st.at_end())); |
|
1450 |
||
1451 |
jmethodID catch_jmethodID; |
|
1452 |
if (current_bci < 0) { |
|
1453 |
catch_jmethodID = 0; |
|
1454 |
current_bci = 0; |
|
1455 |
} else { |
|
15109
088b1ea04490
8001341: SIGSEGV in methodOopDesc::fast_exception_handler_bci_for(KlassHandle,int,Thread*)+0x3e9.
jiangli
parents:
14490
diff
changeset
|
1456 |
catch_jmethodID = jem.to_jmethodID(current_mh); |
1 | 1457 |
} |
1458 |
||
1459 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1460 |
jvmtiEventException callback = env->callbacks()->Exception; |
|
1461 |
if (callback != NULL) { |
|
1462 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1463 |
jem.jni_methodID(), jem.location(), |
|
1464 |
jem.exception(), |
|
1465 |
catch_jmethodID, current_bci); |
|
1466 |
} |
|
1467 |
} |
|
1468 |
} |
|
1469 |
} |
|
1470 |
||
1471 |
// frames may get popped because of this throw, be safe - invalidate cached depth |
|
1472 |
state->invalidate_cur_stack_depth(); |
|
1473 |
} |
|
1474 |
||
1475 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1476 |
void JvmtiExport::notice_unwind_due_to_exception(JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) { |
1 | 1477 |
HandleMark hm(thread); |
1478 |
methodHandle mh(thread, method); |
|
1479 |
Handle exception_handle(thread, exception); |
|
1480 |
||
1481 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1482 |
if (state == NULL) { |
|
1483 |
return; |
|
1484 |
} |
|
1485 |
EVT_TRIG_TRACE(JVMTI_EVENT_EXCEPTION_CATCH, |
|
37992 | 1486 |
("[%s] Trg unwind_due_to_exception triggered %s.%s @ %s" INTX_FORMAT " - %s", |
1 | 1487 |
JvmtiTrace::safe_get_thread_name(thread), |
1488 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1489 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
1490 |
location==0? "no location:" : "", |
|
1491 |
location==0? 0 : location - mh()->code_base(), |
|
1492 |
in_handler_frame? "in handler frame" : "not handler frame" )); |
|
1493 |
||
1494 |
if (state->is_exception_detected()) { |
|
1495 |
||
1496 |
state->invalidate_cur_stack_depth(); |
|
1497 |
if (!in_handler_frame) { |
|
1498 |
// Not in exception handler. |
|
1499 |
if(state->is_interp_only_mode()) { |
|
1500 |
// method exit and frame pop events are posted only in interp mode. |
|
1501 |
// When these events are enabled code should be in running in interp mode. |
|
1502 |
JvmtiExport::post_method_exit(thread, method, thread->last_frame()); |
|
1503 |
// The cached cur_stack_depth might have changed from the |
|
1504 |
// operations of frame pop or method exit. We are not 100% sure |
|
1505 |
// the cached cur_stack_depth is still valid depth so invalidate |
|
1506 |
// it. |
|
1507 |
state->invalidate_cur_stack_depth(); |
|
1508 |
} |
|
1509 |
} else { |
|
1510 |
// In exception handler frame. Report exception catch. |
|
1511 |
assert(location != NULL, "must be a known location"); |
|
1512 |
// Update cur_stack_depth - the frames above the current frame |
|
1513 |
// have been unwound due to this exception: |
|
1514 |
assert(!state->is_exception_caught(), "exception must not be caught yet."); |
|
1515 |
state->set_exception_caught(); |
|
1516 |
||
1517 |
JvmtiEnvThreadStateIterator it(state); |
|
1518 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1519 |
if (ets->is_enabled(JVMTI_EVENT_EXCEPTION_CATCH) && (exception_handle() != NULL)) { |
|
1520 |
EVT_TRACE(JVMTI_EVENT_EXCEPTION_CATCH, |
|
37992 | 1521 |
("[%s] Evt ExceptionCatch sent %s.%s @ " INTX_FORMAT, |
1 | 1522 |
JvmtiTrace::safe_get_thread_name(thread), |
1523 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1524 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
1525 |
location - mh()->code_base() )); |
|
1526 |
||
1527 |
JvmtiEnv *env = ets->get_env(); |
|
1528 |
JvmtiExceptionEventMark jem(thread, mh, location, exception_handle); |
|
1529 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1530 |
jvmtiEventExceptionCatch callback = env->callbacks()->ExceptionCatch; |
|
1531 |
if (callback != NULL) { |
|
1532 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1533 |
jem.jni_methodID(), jem.location(), |
|
1534 |
jem.exception()); |
|
1535 |
} |
|
1536 |
} |
|
1537 |
} |
|
1538 |
} |
|
1539 |
} |
|
1540 |
} |
|
1541 |
||
1542 |
oop JvmtiExport::jni_GetField_probe(JavaThread *thread, jobject jobj, oop obj, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1543 |
Klass* klass, jfieldID fieldID, bool is_static) { |
1 | 1544 |
if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) { |
1545 |
// At least one field access watch is set so we have more work |
|
1546 |
// to do. This wrapper is used by entry points that allow us |
|
1547 |
// to create handles in post_field_access_by_jni(). |
|
1548 |
post_field_access_by_jni(thread, obj, klass, fieldID, is_static); |
|
1549 |
// event posting can block so refetch oop if we were passed a jobj |
|
1550 |
if (jobj != NULL) return JNIHandles::resolve_non_null(jobj); |
|
1551 |
} |
|
1552 |
return obj; |
|
1553 |
} |
|
1554 |
||
1555 |
oop JvmtiExport::jni_GetField_probe_nh(JavaThread *thread, jobject jobj, oop obj, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1556 |
Klass* klass, jfieldID fieldID, bool is_static) { |
1 | 1557 |
if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) { |
1558 |
// At least one field access watch is set so we have more work |
|
1559 |
// to do. This wrapper is used by "quick" entry points that don't |
|
1560 |
// allow us to create handles in post_field_access_by_jni(). We |
|
1561 |
// override that with a ResetNoHandleMark. |
|
1562 |
ResetNoHandleMark rnhm; |
|
1563 |
post_field_access_by_jni(thread, obj, klass, fieldID, is_static); |
|
1564 |
// event posting can block so refetch oop if we were passed a jobj |
|
1565 |
if (jobj != NULL) return JNIHandles::resolve_non_null(jobj); |
|
1566 |
} |
|
1567 |
return obj; |
|
1568 |
} |
|
1569 |
||
1570 |
void JvmtiExport::post_field_access_by_jni(JavaThread *thread, oop obj, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1571 |
Klass* klass, jfieldID fieldID, bool is_static) { |
1 | 1572 |
// We must be called with a Java context in order to provide reasonable |
1573 |
// values for the klazz, method, and location fields. The callers of this |
|
1574 |
// function don't make the call unless there is a Java context. |
|
1575 |
assert(thread->has_last_Java_frame(), "must be called with a Java context"); |
|
1576 |
||
1577 |
ResourceMark rm; |
|
1578 |
fieldDescriptor fd; |
|
1579 |
// if get_field_descriptor finds fieldID to be invalid, then we just bail |
|
1580 |
bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd); |
|
1581 |
assert(valid_fieldID == true,"post_field_access_by_jni called with invalid fieldID"); |
|
1582 |
if (!valid_fieldID) return; |
|
1583 |
// field accesses are not watched so bail |
|
1584 |
if (!fd.is_field_access_watched()) return; |
|
1585 |
||
1586 |
HandleMark hm(thread); |
|
1587 |
KlassHandle h_klass(thread, klass); |
|
1588 |
Handle h_obj; |
|
1589 |
if (!is_static) { |
|
1590 |
// non-static field accessors have an object, but we need a handle |
|
1591 |
assert(obj != NULL, "non-static needs an object"); |
|
1592 |
h_obj = Handle(thread, obj); |
|
1593 |
} |
|
1594 |
post_field_access(thread, |
|
1595 |
thread->last_frame().interpreter_frame_method(), |
|
1596 |
thread->last_frame().interpreter_frame_bcp(), |
|
1597 |
h_klass, h_obj, fieldID); |
|
1598 |
} |
|
1599 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1600 |
void JvmtiExport::post_field_access(JavaThread *thread, Method* method, |
1 | 1601 |
address location, KlassHandle field_klass, Handle object, jfieldID field) { |
1602 |
||
1603 |
HandleMark hm(thread); |
|
1604 |
methodHandle mh(thread, method); |
|
1605 |
||
1606 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1607 |
if (state == NULL) { |
|
1608 |
return; |
|
1609 |
} |
|
37992 | 1610 |
EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Trg Field Access event triggered", |
1 | 1611 |
JvmtiTrace::safe_get_thread_name(thread))); |
1612 |
JvmtiEnvThreadStateIterator it(state); |
|
1613 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1614 |
if (ets->is_enabled(JVMTI_EVENT_FIELD_ACCESS)) { |
|
37992 | 1615 |
EVT_TRACE(JVMTI_EVENT_FIELD_ACCESS, ("[%s] Evt Field Access event sent %s.%s @ " INTX_FORMAT, |
1 | 1616 |
JvmtiTrace::safe_get_thread_name(thread), |
1617 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1618 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
1619 |
location - mh()->code_base() )); |
|
1620 |
||
1621 |
JvmtiEnv *env = ets->get_env(); |
|
1622 |
JvmtiLocationEventMark jem(thread, mh, location); |
|
1623 |
jclass field_jclass = jem.to_jclass(field_klass()); |
|
1624 |
jobject field_jobject = jem.to_jobject(object()); |
|
1625 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1626 |
jvmtiEventFieldAccess callback = env->callbacks()->FieldAccess; |
|
1627 |
if (callback != NULL) { |
|
1628 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1629 |
jem.jni_methodID(), jem.location(), |
|
1630 |
field_jclass, field_jobject, field); |
|
1631 |
} |
|
1632 |
} |
|
1633 |
} |
|
1634 |
} |
|
1635 |
||
1636 |
oop JvmtiExport::jni_SetField_probe(JavaThread *thread, jobject jobj, oop obj, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1637 |
Klass* klass, jfieldID fieldID, bool is_static, |
1 | 1638 |
char sig_type, jvalue *value) { |
1639 |
if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) { |
|
1640 |
// At least one field modification watch is set so we have more work |
|
1641 |
// to do. This wrapper is used by entry points that allow us |
|
1642 |
// to create handles in post_field_modification_by_jni(). |
|
1643 |
post_field_modification_by_jni(thread, obj, klass, fieldID, is_static, sig_type, value); |
|
1644 |
// event posting can block so refetch oop if we were passed a jobj |
|
1645 |
if (jobj != NULL) return JNIHandles::resolve_non_null(jobj); |
|
1646 |
} |
|
1647 |
return obj; |
|
1648 |
} |
|
1649 |
||
1650 |
oop JvmtiExport::jni_SetField_probe_nh(JavaThread *thread, jobject jobj, oop obj, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1651 |
Klass* klass, jfieldID fieldID, bool is_static, |
1 | 1652 |
char sig_type, jvalue *value) { |
1653 |
if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) { |
|
1654 |
// At least one field modification watch is set so we have more work |
|
1655 |
// to do. This wrapper is used by "quick" entry points that don't |
|
1656 |
// allow us to create handles in post_field_modification_by_jni(). We |
|
1657 |
// override that with a ResetNoHandleMark. |
|
1658 |
ResetNoHandleMark rnhm; |
|
1659 |
post_field_modification_by_jni(thread, obj, klass, fieldID, is_static, sig_type, value); |
|
1660 |
// event posting can block so refetch oop if we were passed a jobj |
|
1661 |
if (jobj != NULL) return JNIHandles::resolve_non_null(jobj); |
|
1662 |
} |
|
1663 |
return obj; |
|
1664 |
} |
|
1665 |
||
1666 |
void JvmtiExport::post_field_modification_by_jni(JavaThread *thread, oop obj, |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1667 |
Klass* klass, jfieldID fieldID, bool is_static, |
1 | 1668 |
char sig_type, jvalue *value) { |
1669 |
// We must be called with a Java context in order to provide reasonable |
|
1670 |
// values for the klazz, method, and location fields. The callers of this |
|
1671 |
// function don't make the call unless there is a Java context. |
|
1672 |
assert(thread->has_last_Java_frame(), "must be called with Java context"); |
|
1673 |
||
1674 |
ResourceMark rm; |
|
1675 |
fieldDescriptor fd; |
|
1676 |
// if get_field_descriptor finds fieldID to be invalid, then we just bail |
|
1677 |
bool valid_fieldID = JvmtiEnv::get_field_descriptor(klass, fieldID, &fd); |
|
1678 |
assert(valid_fieldID == true,"post_field_modification_by_jni called with invalid fieldID"); |
|
1679 |
if (!valid_fieldID) return; |
|
1680 |
// field modifications are not watched so bail |
|
1681 |
if (!fd.is_field_modification_watched()) return; |
|
1682 |
||
1683 |
HandleMark hm(thread); |
|
1684 |
||
1685 |
Handle h_obj; |
|
1686 |
if (!is_static) { |
|
1687 |
// non-static field accessors have an object, but we need a handle |
|
1688 |
assert(obj != NULL, "non-static needs an object"); |
|
1689 |
h_obj = Handle(thread, obj); |
|
1690 |
} |
|
1691 |
KlassHandle h_klass(thread, klass); |
|
1692 |
post_field_modification(thread, |
|
1693 |
thread->last_frame().interpreter_frame_method(), |
|
1694 |
thread->last_frame().interpreter_frame_bcp(), |
|
1695 |
h_klass, h_obj, fieldID, sig_type, value); |
|
1696 |
} |
|
1697 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1698 |
void JvmtiExport::post_raw_field_modification(JavaThread *thread, Method* method, |
1 | 1699 |
address location, KlassHandle field_klass, Handle object, jfieldID field, |
1700 |
char sig_type, jvalue *value) { |
|
1701 |
||
37480 | 1702 |
if (sig_type == 'I' || sig_type == 'Z' || sig_type == 'B' || sig_type == 'C' || sig_type == 'S') { |
1 | 1703 |
// 'I' instructions are used for byte, char, short and int. |
1704 |
// determine which it really is, and convert |
|
1705 |
fieldDescriptor fd; |
|
1706 |
bool found = JvmtiEnv::get_field_descriptor(field_klass(), field, &fd); |
|
1707 |
// should be found (if not, leave as is) |
|
1708 |
if (found) { |
|
1709 |
jint ival = value->i; |
|
1710 |
// convert value from int to appropriate type |
|
1711 |
switch (fd.field_type()) { |
|
1712 |
case T_BOOLEAN: |
|
1713 |
sig_type = 'Z'; |
|
1714 |
value->i = 0; // clear it |
|
1715 |
value->z = (jboolean)ival; |
|
1716 |
break; |
|
1717 |
case T_BYTE: |
|
1718 |
sig_type = 'B'; |
|
1719 |
value->i = 0; // clear it |
|
1720 |
value->b = (jbyte)ival; |
|
1721 |
break; |
|
1722 |
case T_CHAR: |
|
1723 |
sig_type = 'C'; |
|
1724 |
value->i = 0; // clear it |
|
1725 |
value->c = (jchar)ival; |
|
1726 |
break; |
|
1727 |
case T_SHORT: |
|
1728 |
sig_type = 'S'; |
|
1729 |
value->i = 0; // clear it |
|
1730 |
value->s = (jshort)ival; |
|
1731 |
break; |
|
1732 |
case T_INT: |
|
1733 |
// nothing to do |
|
1734 |
break; |
|
1735 |
default: |
|
1736 |
// this is an integer instruction, should be one of above |
|
1737 |
ShouldNotReachHere(); |
|
1738 |
break; |
|
1739 |
} |
|
1740 |
} |
|
1741 |
} |
|
1742 |
||
17597
48ed8470e935
4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd
rbackman
parents:
17368
diff
changeset
|
1743 |
assert(sig_type != '[', "array should have sig_type == 'L'"); |
48ed8470e935
4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd
rbackman
parents:
17368
diff
changeset
|
1744 |
bool handle_created = false; |
48ed8470e935
4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd
rbackman
parents:
17368
diff
changeset
|
1745 |
|
1 | 1746 |
// convert oop to JNI handle. |
17597
48ed8470e935
4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd
rbackman
parents:
17368
diff
changeset
|
1747 |
if (sig_type == 'L') { |
48ed8470e935
4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd
rbackman
parents:
17368
diff
changeset
|
1748 |
handle_created = true; |
1 | 1749 |
value->l = (jobject)JNIHandles::make_local(thread, (oop)value->l); |
1750 |
} |
|
1751 |
||
1752 |
post_field_modification(thread, method, location, field_klass, object, field, sig_type, value); |
|
1753 |
||
1754 |
// Destroy the JNI handle allocated above. |
|
17597
48ed8470e935
4965252: JvmtiExport::post_raw_field_modification jni ref handling is odd
rbackman
parents:
17368
diff
changeset
|
1755 |
if (handle_created) { |
1 | 1756 |
JNIHandles::destroy_local(value->l); |
1757 |
} |
|
1758 |
} |
|
1759 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1760 |
void JvmtiExport::post_field_modification(JavaThread *thread, Method* method, |
1 | 1761 |
address location, KlassHandle field_klass, Handle object, jfieldID field, |
1762 |
char sig_type, jvalue *value_ptr) { |
|
1763 |
||
1764 |
HandleMark hm(thread); |
|
1765 |
methodHandle mh(thread, method); |
|
1766 |
||
1767 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
1768 |
if (state == NULL) { |
|
1769 |
return; |
|
1770 |
} |
|
1771 |
EVT_TRIG_TRACE(JVMTI_EVENT_FIELD_MODIFICATION, |
|
37992 | 1772 |
("[%s] Trg Field Modification event triggered", |
1 | 1773 |
JvmtiTrace::safe_get_thread_name(thread))); |
1774 |
||
1775 |
JvmtiEnvThreadStateIterator it(state); |
|
1776 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
1777 |
if (ets->is_enabled(JVMTI_EVENT_FIELD_MODIFICATION)) { |
|
1778 |
EVT_TRACE(JVMTI_EVENT_FIELD_MODIFICATION, |
|
37992 | 1779 |
("[%s] Evt Field Modification event sent %s.%s @ " INTX_FORMAT, |
1 | 1780 |
JvmtiTrace::safe_get_thread_name(thread), |
1781 |
(mh() == NULL) ? "NULL" : mh()->klass_name()->as_C_string(), |
|
1782 |
(mh() == NULL) ? "NULL" : mh()->name()->as_C_string(), |
|
1783 |
location - mh()->code_base() )); |
|
1784 |
||
1785 |
JvmtiEnv *env = ets->get_env(); |
|
1786 |
JvmtiLocationEventMark jem(thread, mh, location); |
|
1787 |
jclass field_jclass = jem.to_jclass(field_klass()); |
|
1788 |
jobject field_jobject = jem.to_jobject(object()); |
|
1789 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1790 |
jvmtiEventFieldModification callback = env->callbacks()->FieldModification; |
|
1791 |
if (callback != NULL) { |
|
1792 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
1793 |
jem.jni_methodID(), jem.location(), |
|
1794 |
field_jclass, field_jobject, field, sig_type, *value_ptr); |
|
1795 |
} |
|
1796 |
} |
|
1797 |
} |
|
1798 |
} |
|
1799 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1800 |
void JvmtiExport::post_native_method_bind(Method* method, address* function_ptr) { |
1 | 1801 |
JavaThread* thread = JavaThread::current(); |
1802 |
assert(thread->thread_state() == _thread_in_vm, "must be in vm state"); |
|
1803 |
||
1804 |
HandleMark hm(thread); |
|
1805 |
methodHandle mh(thread, method); |
|
1806 |
||
37992 | 1807 |
EVT_TRIG_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Trg Native Method Bind event triggered", |
1 | 1808 |
JvmtiTrace::safe_get_thread_name(thread))); |
1809 |
||
1810 |
if (JvmtiEventController::is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) { |
|
1811 |
JvmtiEnvIterator it; |
|
1812 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
1813 |
if (env->is_enabled(JVMTI_EVENT_NATIVE_METHOD_BIND)) { |
|
37992 | 1814 |
EVT_TRACE(JVMTI_EVENT_NATIVE_METHOD_BIND, ("[%s] Evt Native Method Bind event sent", |
1 | 1815 |
JvmtiTrace::safe_get_thread_name(thread) )); |
1816 |
||
1817 |
JvmtiMethodEventMark jem(thread, mh); |
|
1818 |
JvmtiJavaThreadEventTransition jet(thread); |
|
36508 | 1819 |
JNIEnv* jni_env = (env->phase() == JVMTI_PHASE_PRIMORDIAL) ? NULL : jem.jni_env(); |
1 | 1820 |
jvmtiEventNativeMethodBind callback = env->callbacks()->NativeMethodBind; |
1821 |
if (callback != NULL) { |
|
1822 |
(*callback)(env->jvmti_external(), jni_env, jem.jni_thread(), |
|
1823 |
jem.jni_methodID(), (void*)(*function_ptr), (void**)function_ptr); |
|
1824 |
} |
|
1825 |
} |
|
1826 |
} |
|
1827 |
} |
|
1828 |
} |
|
1829 |
||
4732
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1830 |
// Returns a record containing inlining information for the given nmethod |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1831 |
jvmtiCompiledMethodLoadInlineRecord* create_inline_record(nmethod* nm) { |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1832 |
jint numstackframes = 0; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1833 |
jvmtiCompiledMethodLoadInlineRecord* record = (jvmtiCompiledMethodLoadInlineRecord*)NEW_RESOURCE_OBJ(jvmtiCompiledMethodLoadInlineRecord); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1834 |
record->header.kind = JVMTI_CMLR_INLINE_INFO; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1835 |
record->header.next = NULL; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1836 |
record->header.majorinfoversion = JVMTI_CMLR_MAJOR_VERSION_1; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1837 |
record->header.minorinfoversion = JVMTI_CMLR_MINOR_VERSION_0; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1838 |
record->numpcs = 0; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1839 |
for(PcDesc* p = nm->scopes_pcs_begin(); p < nm->scopes_pcs_end(); p++) { |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1840 |
if(p->scope_decode_offset() == DebugInformationRecorder::serialized_null) continue; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1841 |
record->numpcs++; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1842 |
} |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1843 |
record->pcinfo = (PCStackInfo*)(NEW_RESOURCE_ARRAY(PCStackInfo, record->numpcs)); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1844 |
int scope = 0; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1845 |
for(PcDesc* p = nm->scopes_pcs_begin(); p < nm->scopes_pcs_end(); p++) { |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1846 |
if(p->scope_decode_offset() == DebugInformationRecorder::serialized_null) continue; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1847 |
void* pc_address = (void*)p->real_pc(nm); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1848 |
assert(pc_address != NULL, "pc_address must be non-null"); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1849 |
record->pcinfo[scope].pc = pc_address; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1850 |
numstackframes=0; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1851 |
for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != NULL;sd = sd->sender()) { |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1852 |
numstackframes++; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1853 |
} |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1854 |
assert(numstackframes != 0, "numstackframes must be nonzero."); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1855 |
record->pcinfo[scope].methods = (jmethodID *)NEW_RESOURCE_ARRAY(jmethodID, numstackframes); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1856 |
record->pcinfo[scope].bcis = (jint *)NEW_RESOURCE_ARRAY(jint, numstackframes); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1857 |
record->pcinfo[scope].numstackframes = numstackframes; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1858 |
int stackframe = 0; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1859 |
for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != NULL;sd = sd->sender()) { |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1860 |
// sd->method() can be NULL for stubs but not for nmethods. To be completely robust, include an assert that we should never see a null sd->method() |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13195
diff
changeset
|
1861 |
assert(sd->method() != NULL, "sd->method() cannot be null."); |
4732
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1862 |
record->pcinfo[scope].methods[stackframe] = sd->method()->jmethod_id(); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1863 |
record->pcinfo[scope].bcis[stackframe] = sd->bci(); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1864 |
stackframe++; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1865 |
} |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1866 |
scope++; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1867 |
} |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1868 |
return record; |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1869 |
} |
1 | 1870 |
|
1871 |
void JvmtiExport::post_compiled_method_load(nmethod *nm) { |
|
36508 | 1872 |
if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) { |
1873 |
return; |
|
1874 |
} |
|
1 | 1875 |
JavaThread* thread = JavaThread::current(); |
1876 |
||
1877 |
EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD, |
|
37992 | 1878 |
("[%s] method compile load event triggered", |
1 | 1879 |
JvmtiTrace::safe_get_thread_name(thread))); |
1880 |
||
1881 |
JvmtiEnvIterator it; |
|
1882 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
1883 |
if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_LOAD)) { |
|
36508 | 1884 |
if (env->phase() == JVMTI_PHASE_PRIMORDIAL) { |
1885 |
continue; |
|
1886 |
} |
|
1 | 1887 |
EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD, |
37992 | 1888 |
("[%s] class compile method load event sent %s.%s ", |
1 | 1889 |
JvmtiTrace::safe_get_thread_name(thread), |
1890 |
(nm->method() == NULL) ? "NULL" : nm->method()->klass_name()->as_C_string(), |
|
1891 |
(nm->method() == NULL) ? "NULL" : nm->method()->name()->as_C_string())); |
|
1892 |
ResourceMark rm(thread); |
|
8110
c992c8d52344
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
8076
diff
changeset
|
1893 |
HandleMark hm(thread); |
4732
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1894 |
|
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1895 |
// Add inlining information |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1896 |
jvmtiCompiledMethodLoadInlineRecord* inlinerecord = create_inline_record(nm); |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1897 |
// Pass inlining information through the void pointer |
a70548606f73
6580131: 3/4 CompiledMethodLoad events don't produce the expected extra notifications to describe inlining
dcubed
parents:
4491
diff
changeset
|
1898 |
JvmtiCompiledMethodLoadEventMark jem(thread, nm, inlinerecord); |
1 | 1899 |
JvmtiJavaThreadEventTransition jet(thread); |
1900 |
jvmtiEventCompiledMethodLoad callback = env->callbacks()->CompiledMethodLoad; |
|
1901 |
if (callback != NULL) { |
|
1902 |
(*callback)(env->jvmti_external(), jem.jni_methodID(), |
|
1903 |
jem.code_size(), jem.code_data(), jem.map_length(), |
|
1904 |
jem.map(), jem.compile_info()); |
|
1905 |
} |
|
1906 |
} |
|
1907 |
} |
|
1908 |
} |
|
1909 |
||
1910 |
||
1911 |
// post a COMPILED_METHOD_LOAD event for a given environment |
|
1912 |
void JvmtiExport::post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length, |
|
1913 |
const void *code_begin, const jint map_length, |
|
1914 |
const jvmtiAddrLocationMap* map) |
|
1915 |
{ |
|
36508 | 1916 |
if (env->phase() <= JVMTI_PHASE_PRIMORDIAL) { |
1917 |
return; |
|
1918 |
} |
|
1 | 1919 |
JavaThread* thread = JavaThread::current(); |
1920 |
EVT_TRIG_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD, |
|
37992 | 1921 |
("[%s] method compile load event triggered (by GenerateEvents)", |
1 | 1922 |
JvmtiTrace::safe_get_thread_name(thread))); |
1923 |
if (env->is_enabled(JVMTI_EVENT_COMPILED_METHOD_LOAD)) { |
|
1924 |
||
1925 |
EVT_TRACE(JVMTI_EVENT_COMPILED_METHOD_LOAD, |
|
37992 | 1926 |
("[%s] class compile method load event sent (by GenerateEvents), jmethodID=" PTR_FORMAT, |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
32817
diff
changeset
|
1927 |
JvmtiTrace::safe_get_thread_name(thread), p2i(method))); |
1 | 1928 |
|
1929 |
JvmtiEventMark jem(thread); |
|
1930 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1931 |
jvmtiEventCompiledMethodLoad callback = env->callbacks()->CompiledMethodLoad; |
|
1932 |
if (callback != NULL) { |
|
1933 |
(*callback)(env->jvmti_external(), method, |
|
1934 |
length, code_begin, map_length, |
|
1935 |
map, NULL); |
|
1936 |
} |
|
1937 |
} |
|
1938 |
} |
|
1939 |
||
1940 |
void JvmtiExport::post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) { |
|
9405
d2e9ee78c3c1
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
8475
diff
changeset
|
1941 |
assert(name != NULL && name[0] != '\0', "sanity check"); |
d2e9ee78c3c1
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
8475
diff
changeset
|
1942 |
|
1 | 1943 |
JavaThread* thread = JavaThread::current(); |
8475
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1944 |
// In theory everyone coming thru here is in_vm but we need to be certain |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1945 |
// because a callee will do a vm->native transition |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1946 |
ThreadInVMfromUnknown __tiv; |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1947 |
|
1 | 1948 |
EVT_TRIG_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, |
37992 | 1949 |
("[%s] method dynamic code generated event triggered", |
1 | 1950 |
JvmtiTrace::safe_get_thread_name(thread))); |
1951 |
JvmtiEnvIterator it; |
|
1952 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
1953 |
if (env->is_enabled(JVMTI_EVENT_DYNAMIC_CODE_GENERATED)) { |
|
1954 |
EVT_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, |
|
37992 | 1955 |
("[%s] dynamic code generated event sent for %s", |
1 | 1956 |
JvmtiTrace::safe_get_thread_name(thread), name)); |
1957 |
JvmtiEventMark jem(thread); |
|
1958 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1959 |
jint length = (jint)pointer_delta(code_end, code_begin, sizeof(char)); |
|
1960 |
jvmtiEventDynamicCodeGenerated callback = env->callbacks()->DynamicCodeGenerated; |
|
1961 |
if (callback != NULL) { |
|
1962 |
(*callback)(env->jvmti_external(), name, (void*)code_begin, length); |
|
1963 |
} |
|
1964 |
} |
|
1965 |
} |
|
1966 |
} |
|
1967 |
||
1968 |
void JvmtiExport::post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) { |
|
1969 |
jvmtiPhase phase = JvmtiEnv::get_phase(); |
|
1970 |
if (phase == JVMTI_PHASE_PRIMORDIAL || phase == JVMTI_PHASE_START) { |
|
1971 |
post_dynamic_code_generated_internal(name, code_begin, code_end); |
|
8475
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1972 |
} else { |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1973 |
// It may not be safe to post the event from this thread. Defer all |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1974 |
// postings to the service thread so that it can perform them in a safe |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1975 |
// context and in-order. |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1976 |
MutexLockerEx ml(Service_lock, Mutex::_no_safepoint_check_flag); |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1977 |
JvmtiDeferredEvent event = JvmtiDeferredEvent::dynamic_code_generated_event( |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1978 |
name, code_begin, code_end); |
c2b97a27943a
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
8110
diff
changeset
|
1979 |
JvmtiDeferredEventQueue::enqueue(event); |
1 | 1980 |
} |
1981 |
} |
|
1982 |
||
1983 |
||
1984 |
// post a DYNAMIC_CODE_GENERATED event for a given environment |
|
1985 |
// used by GenerateEvents |
|
1986 |
void JvmtiExport::post_dynamic_code_generated(JvmtiEnv* env, const char *name, |
|
1987 |
const void *code_begin, const void *code_end) |
|
1988 |
{ |
|
1989 |
JavaThread* thread = JavaThread::current(); |
|
1990 |
EVT_TRIG_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, |
|
37992 | 1991 |
("[%s] dynamic code generated event triggered (by GenerateEvents)", |
1 | 1992 |
JvmtiTrace::safe_get_thread_name(thread))); |
1993 |
if (env->is_enabled(JVMTI_EVENT_DYNAMIC_CODE_GENERATED)) { |
|
1994 |
EVT_TRACE(JVMTI_EVENT_DYNAMIC_CODE_GENERATED, |
|
37992 | 1995 |
("[%s] dynamic code generated event sent for %s", |
1 | 1996 |
JvmtiTrace::safe_get_thread_name(thread), name)); |
1997 |
JvmtiEventMark jem(thread); |
|
1998 |
JvmtiJavaThreadEventTransition jet(thread); |
|
1999 |
jint length = (jint)pointer_delta(code_end, code_begin, sizeof(char)); |
|
2000 |
jvmtiEventDynamicCodeGenerated callback = env->callbacks()->DynamicCodeGenerated; |
|
2001 |
if (callback != NULL) { |
|
2002 |
(*callback)(env->jvmti_external(), name, (void*)code_begin, length); |
|
2003 |
} |
|
2004 |
} |
|
2005 |
} |
|
2006 |
||
2007 |
// post a DynamicCodeGenerated event while holding locks in the VM. |
|
2008 |
void JvmtiExport::post_dynamic_code_generated_while_holding_locks(const char* name, |
|
2009 |
address code_begin, address code_end) |
|
2010 |
{ |
|
2011 |
// register the stub with the current dynamic code event collector |
|
2012 |
JvmtiThreadState* state = JvmtiThreadState::state_for(JavaThread::current()); |
|
2135
f82c3012ec86
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
1374
diff
changeset
|
2013 |
// state can only be NULL if the current thread is exiting which |
f82c3012ec86
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
1374
diff
changeset
|
2014 |
// should not happen since we're trying to post an event |
f82c3012ec86
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
1374
diff
changeset
|
2015 |
guarantee(state != NULL, "attempt to register stub via an exiting thread"); |
1 | 2016 |
JvmtiDynamicCodeEventCollector* collector = state->get_dynamic_code_event_collector(); |
2017 |
guarantee(collector != NULL, "attempt to register stub without event collector"); |
|
2018 |
collector->register_stub(name, code_begin, code_end); |
|
2019 |
} |
|
2020 |
||
2021 |
// Collect all the vm internally allocated objects which are visible to java world |
|
2022 |
void JvmtiExport::record_vm_internal_object_allocation(oop obj) { |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
33148
diff
changeset
|
2023 |
Thread* thread = Thread::current_or_null(); |
1 | 2024 |
if (thread != NULL && thread->is_Java_thread()) { |
2025 |
// Can not take safepoint here. |
|
35492
c8c0273e6b91
8146690: Make all classes in GC follow the naming convention.
david
parents:
34633
diff
changeset
|
2026 |
NoSafepointVerifier no_sfpt; |
1 | 2027 |
// Can not take safepoint here so can not use state_for to get |
2028 |
// jvmti thread state. |
|
2029 |
JvmtiThreadState *state = ((JavaThread*)thread)->jvmti_thread_state(); |
|
2030 |
if (state != NULL ) { |
|
2031 |
// state is non NULL when VMObjectAllocEventCollector is enabled. |
|
2032 |
JvmtiVMObjectAllocEventCollector *collector; |
|
2033 |
collector = state->get_vm_object_alloc_event_collector(); |
|
2034 |
if (collector != NULL && collector->is_enabled()) { |
|
2035 |
// Don't record classes as these will be notified via the ClassLoad |
|
2036 |
// event. |
|
4571 | 2037 |
if (obj->klass() != SystemDictionary::Class_klass()) { |
1 | 2038 |
collector->record_allocation(obj); |
2039 |
} |
|
2040 |
} |
|
2041 |
} |
|
2042 |
} |
|
2043 |
} |
|
2044 |
||
2045 |
void JvmtiExport::post_garbage_collection_finish() { |
|
2046 |
Thread *thread = Thread::current(); // this event is posted from VM-Thread. |
|
2047 |
EVT_TRIG_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH, |
|
37992 | 2048 |
("[%s] garbage collection finish event triggered", |
1 | 2049 |
JvmtiTrace::safe_get_thread_name(thread))); |
2050 |
JvmtiEnvIterator it; |
|
2051 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
2052 |
if (env->is_enabled(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH)) { |
|
2053 |
EVT_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_FINISH, |
|
37992 | 2054 |
("[%s] garbage collection finish event sent", |
1 | 2055 |
JvmtiTrace::safe_get_thread_name(thread))); |
2056 |
JvmtiThreadEventTransition jet(thread); |
|
2057 |
// JNIEnv is NULL here because this event is posted from VM Thread |
|
2058 |
jvmtiEventGarbageCollectionFinish callback = env->callbacks()->GarbageCollectionFinish; |
|
2059 |
if (callback != NULL) { |
|
2060 |
(*callback)(env->jvmti_external()); |
|
2061 |
} |
|
2062 |
} |
|
2063 |
} |
|
2064 |
} |
|
2065 |
||
2066 |
void JvmtiExport::post_garbage_collection_start() { |
|
2067 |
Thread* thread = Thread::current(); // this event is posted from vm-thread. |
|
2068 |
EVT_TRIG_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_START, |
|
37992 | 2069 |
("[%s] garbage collection start event triggered", |
1 | 2070 |
JvmtiTrace::safe_get_thread_name(thread))); |
2071 |
JvmtiEnvIterator it; |
|
2072 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
2073 |
if (env->is_enabled(JVMTI_EVENT_GARBAGE_COLLECTION_START)) { |
|
2074 |
EVT_TRACE(JVMTI_EVENT_GARBAGE_COLLECTION_START, |
|
37992 | 2075 |
("[%s] garbage collection start event sent", |
1 | 2076 |
JvmtiTrace::safe_get_thread_name(thread))); |
2077 |
JvmtiThreadEventTransition jet(thread); |
|
2078 |
// JNIEnv is NULL here because this event is posted from VM Thread |
|
2079 |
jvmtiEventGarbageCollectionStart callback = env->callbacks()->GarbageCollectionStart; |
|
2080 |
if (callback != NULL) { |
|
2081 |
(*callback)(env->jvmti_external()); |
|
2082 |
} |
|
2083 |
} |
|
2084 |
} |
|
2085 |
} |
|
2086 |
||
2087 |
void JvmtiExport::post_data_dump() { |
|
2088 |
Thread *thread = Thread::current(); |
|
2089 |
EVT_TRIG_TRACE(JVMTI_EVENT_DATA_DUMP_REQUEST, |
|
37992 | 2090 |
("[%s] data dump request event triggered", |
1 | 2091 |
JvmtiTrace::safe_get_thread_name(thread))); |
2092 |
JvmtiEnvIterator it; |
|
2093 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
2094 |
if (env->is_enabled(JVMTI_EVENT_DATA_DUMP_REQUEST)) { |
|
2095 |
EVT_TRACE(JVMTI_EVENT_DATA_DUMP_REQUEST, |
|
37992 | 2096 |
("[%s] data dump request event sent", |
1 | 2097 |
JvmtiTrace::safe_get_thread_name(thread))); |
2098 |
JvmtiThreadEventTransition jet(thread); |
|
2099 |
// JNIEnv is NULL here because this event is posted from VM Thread |
|
2100 |
jvmtiEventDataDumpRequest callback = env->callbacks()->DataDumpRequest; |
|
2101 |
if (callback != NULL) { |
|
2102 |
(*callback)(env->jvmti_external()); |
|
2103 |
} |
|
2104 |
} |
|
2105 |
} |
|
2106 |
} |
|
2107 |
||
2108 |
void JvmtiExport::post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) { |
|
2109 |
oop object = (oop)obj_mntr->object(); |
|
2110 |
if (!ServiceUtil::visible_oop(object)) { |
|
2111 |
// Ignore monitor contended enter for vm internal object. |
|
2112 |
return; |
|
2113 |
} |
|
2114 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
2115 |
if (state == NULL) { |
|
2116 |
return; |
|
2117 |
} |
|
2118 |
||
2119 |
HandleMark hm(thread); |
|
2120 |
Handle h(thread, object); |
|
2121 |
||
2122 |
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER, |
|
37992 | 2123 |
("[%s] montior contended enter event triggered", |
1 | 2124 |
JvmtiTrace::safe_get_thread_name(thread))); |
2125 |
||
2126 |
JvmtiEnvThreadStateIterator it(state); |
|
2127 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
2128 |
if (ets->is_enabled(JVMTI_EVENT_MONITOR_CONTENDED_ENTER)) { |
|
2129 |
EVT_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTER, |
|
37992 | 2130 |
("[%s] monitor contended enter event sent", |
1 | 2131 |
JvmtiTrace::safe_get_thread_name(thread))); |
2132 |
JvmtiMonitorEventMark jem(thread, h()); |
|
2133 |
JvmtiEnv *env = ets->get_env(); |
|
2134 |
JvmtiThreadEventTransition jet(thread); |
|
2135 |
jvmtiEventMonitorContendedEnter callback = env->callbacks()->MonitorContendedEnter; |
|
2136 |
if (callback != NULL) { |
|
2137 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_object()); |
|
2138 |
} |
|
2139 |
} |
|
2140 |
} |
|
2141 |
} |
|
2142 |
||
2143 |
void JvmtiExport::post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) { |
|
2144 |
oop object = (oop)obj_mntr->object(); |
|
2145 |
if (!ServiceUtil::visible_oop(object)) { |
|
2146 |
// Ignore monitor contended entered for vm internal object. |
|
2147 |
return; |
|
2148 |
} |
|
2149 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
2150 |
if (state == NULL) { |
|
2151 |
return; |
|
2152 |
} |
|
2153 |
||
2154 |
HandleMark hm(thread); |
|
2155 |
Handle h(thread, object); |
|
2156 |
||
2157 |
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, |
|
37992 | 2158 |
("[%s] montior contended entered event triggered", |
1 | 2159 |
JvmtiTrace::safe_get_thread_name(thread))); |
2160 |
||
2161 |
JvmtiEnvThreadStateIterator it(state); |
|
2162 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
2163 |
if (ets->is_enabled(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED)) { |
|
2164 |
EVT_TRACE(JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, |
|
37992 | 2165 |
("[%s] monitor contended enter event sent", |
1 | 2166 |
JvmtiTrace::safe_get_thread_name(thread))); |
2167 |
JvmtiMonitorEventMark jem(thread, h()); |
|
2168 |
JvmtiEnv *env = ets->get_env(); |
|
2169 |
JvmtiThreadEventTransition jet(thread); |
|
2170 |
jvmtiEventMonitorContendedEntered callback = env->callbacks()->MonitorContendedEntered; |
|
2171 |
if (callback != NULL) { |
|
2172 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), jem.jni_object()); |
|
2173 |
} |
|
2174 |
} |
|
2175 |
} |
|
2176 |
} |
|
2177 |
||
2178 |
void JvmtiExport::post_monitor_wait(JavaThread *thread, oop object, |
|
2179 |
jlong timeout) { |
|
2180 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
2181 |
if (state == NULL) { |
|
2182 |
return; |
|
2183 |
} |
|
2184 |
||
2185 |
HandleMark hm(thread); |
|
2186 |
Handle h(thread, object); |
|
2187 |
||
2188 |
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAIT, |
|
37992 | 2189 |
("[%s] montior wait event triggered", |
1 | 2190 |
JvmtiTrace::safe_get_thread_name(thread))); |
2191 |
||
2192 |
JvmtiEnvThreadStateIterator it(state); |
|
2193 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
2194 |
if (ets->is_enabled(JVMTI_EVENT_MONITOR_WAIT)) { |
|
2195 |
EVT_TRACE(JVMTI_EVENT_MONITOR_WAIT, |
|
37992 | 2196 |
("[%s] monitor wait event sent", |
1 | 2197 |
JvmtiTrace::safe_get_thread_name(thread))); |
2198 |
JvmtiMonitorEventMark jem(thread, h()); |
|
2199 |
JvmtiEnv *env = ets->get_env(); |
|
2200 |
JvmtiThreadEventTransition jet(thread); |
|
2201 |
jvmtiEventMonitorWait callback = env->callbacks()->MonitorWait; |
|
2202 |
if (callback != NULL) { |
|
2203 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
2204 |
jem.jni_object(), timeout); |
|
2205 |
} |
|
2206 |
} |
|
2207 |
} |
|
2208 |
} |
|
2209 |
||
2210 |
void JvmtiExport::post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) { |
|
2211 |
oop object = (oop)obj_mntr->object(); |
|
2212 |
if (!ServiceUtil::visible_oop(object)) { |
|
2213 |
// Ignore monitor waited for vm internal object. |
|
2214 |
return; |
|
2215 |
} |
|
2216 |
JvmtiThreadState *state = thread->jvmti_thread_state(); |
|
2217 |
if (state == NULL) { |
|
2218 |
return; |
|
2219 |
} |
|
2220 |
||
2221 |
HandleMark hm(thread); |
|
2222 |
Handle h(thread, object); |
|
2223 |
||
2224 |
EVT_TRIG_TRACE(JVMTI_EVENT_MONITOR_WAITED, |
|
37992 | 2225 |
("[%s] montior waited event triggered", |
1 | 2226 |
JvmtiTrace::safe_get_thread_name(thread))); |
2227 |
||
2228 |
JvmtiEnvThreadStateIterator it(state); |
|
2229 |
for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { |
|
2230 |
if (ets->is_enabled(JVMTI_EVENT_MONITOR_WAITED)) { |
|
2231 |
EVT_TRACE(JVMTI_EVENT_MONITOR_WAITED, |
|
37992 | 2232 |
("[%s] monitor waited event sent", |
1 | 2233 |
JvmtiTrace::safe_get_thread_name(thread))); |
2234 |
JvmtiMonitorEventMark jem(thread, h()); |
|
2235 |
JvmtiEnv *env = ets->get_env(); |
|
2236 |
JvmtiThreadEventTransition jet(thread); |
|
2237 |
jvmtiEventMonitorWaited callback = env->callbacks()->MonitorWaited; |
|
2238 |
if (callback != NULL) { |
|
2239 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
2240 |
jem.jni_object(), timed_out); |
|
2241 |
} |
|
2242 |
} |
|
2243 |
} |
|
2244 |
} |
|
2245 |
||
2246 |
||
2247 |
void JvmtiExport::post_vm_object_alloc(JavaThread *thread, oop object) { |
|
37992 | 2248 |
EVT_TRIG_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Trg vm object alloc triggered", |
1 | 2249 |
JvmtiTrace::safe_get_thread_name(thread))); |
2250 |
if (object == NULL) { |
|
2251 |
return; |
|
2252 |
} |
|
2253 |
HandleMark hm(thread); |
|
2254 |
Handle h(thread, object); |
|
2255 |
JvmtiEnvIterator it; |
|
2256 |
for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) { |
|
2257 |
if (env->is_enabled(JVMTI_EVENT_VM_OBJECT_ALLOC)) { |
|
37992 | 2258 |
EVT_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("[%s] Evt vmobject alloc sent %s", |
1 | 2259 |
JvmtiTrace::safe_get_thread_name(thread), |
37500 | 2260 |
object==NULL? "NULL" : object->klass()->external_name())); |
1 | 2261 |
|
2262 |
JvmtiVMObjectAllocEventMark jem(thread, h()); |
|
2263 |
JvmtiJavaThreadEventTransition jet(thread); |
|
2264 |
jvmtiEventVMObjectAlloc callback = env->callbacks()->VMObjectAlloc; |
|
2265 |
if (callback != NULL) { |
|
2266 |
(*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread(), |
|
2267 |
jem.jni_jobject(), jem.jni_class(), jem.size()); |
|
2268 |
} |
|
2269 |
} |
|
2270 |
} |
|
2271 |
} |
|
2272 |
||
2273 |
//////////////////////////////////////////////////////////////////////////////////////////////// |
|
2274 |
||
2275 |
void JvmtiExport::cleanup_thread(JavaThread* thread) { |
|
2276 |
assert(JavaThread::current() == thread, "thread is not current"); |
|
7897
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2277 |
MutexLocker mu(JvmtiThreadState_lock); |
1 | 2278 |
|
7897
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2279 |
if (thread->jvmti_thread_state() != NULL) { |
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2280 |
// This has to happen after the thread state is removed, which is |
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2281 |
// why it is not in post_thread_end_event like its complement |
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2282 |
// Maybe both these functions should be rolled into the posts? |
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2283 |
JvmtiEventController::thread_ended(thread); |
201a8b00ec91
6814943: getcpool001 catches more than one JvmtiThreadState problem
kamg
parents:
7896
diff
changeset
|
2284 |
} |
1 | 2285 |
} |
2286 |
||
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2287 |
void JvmtiExport::clear_detected_exception(JavaThread* thread) { |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2288 |
assert(JavaThread::current() == thread, "thread is not current"); |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2289 |
|
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2290 |
JvmtiThreadState* state = thread->jvmti_thread_state(); |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2291 |
if (state != NULL) { |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2292 |
state->clear_exception_detected(); |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2293 |
} |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2294 |
} |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
19553
diff
changeset
|
2295 |
|
1 | 2296 |
void JvmtiExport::oops_do(OopClosure* f) { |
2297 |
JvmtiCurrentBreakpoints::oops_do(f); |
|
2298 |
JvmtiVMObjectAllocEventCollector::oops_do_for_all_threads(f); |
|
2299 |
} |
|
2300 |
||
32817
acc2744fd84b
8136627: Backout JDK-8133818 Additional number of processed references printed with -XX:+PrintReferenceGC after JDK-8047125
kbarrett
parents:
32607
diff
changeset
|
2301 |
void JvmtiExport::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { |
acc2744fd84b
8136627: Backout JDK-8133818 Additional number of processed references printed with -XX:+PrintReferenceGC after JDK-8047125
kbarrett
parents:
32607
diff
changeset
|
2302 |
JvmtiTagMap::weak_oops_do(is_alive, f); |
7918
ce1e4ae77aea
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
7897
diff
changeset
|
2303 |
} |
ce1e4ae77aea
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
7897
diff
changeset
|
2304 |
|
ce1e4ae77aea
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
7897
diff
changeset
|
2305 |
void JvmtiExport::gc_epilogue() { |
ce1e4ae77aea
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
7897
diff
changeset
|
2306 |
JvmtiCurrentBreakpoints::gc_epilogue(); |
ce1e4ae77aea
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
7897
diff
changeset
|
2307 |
} |
ce1e4ae77aea
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
7897
diff
changeset
|
2308 |
|
1 | 2309 |
// Onload raw monitor transition. |
2310 |
void JvmtiExport::transition_pending_onload_raw_monitors() { |
|
2311 |
JvmtiPendingMonitors::transition_raw_monitors(); |
|
2312 |
} |
|
2313 |
||
2314 |
//////////////////////////////////////////////////////////////////////////////////////////////// |
|
37195
88b6f1271f64
8151991: jvmti diagnostics commands requires INCLUDE_SERVICES
dsamersoff
parents:
36508
diff
changeset
|
2315 |
#if INCLUDE_SERVICES |
88b6f1271f64
8151991: jvmti diagnostics commands requires INCLUDE_SERVICES
dsamersoff
parents:
36508
diff
changeset
|
2316 |
// Attach is disabled if SERVICES is not included |
1 | 2317 |
|
2318 |
// type for the Agent_OnAttach entry point |
|
2319 |
extern "C" { |
|
2320 |
typedef jint (JNICALL *OnAttachEntry_t)(JavaVM*, char *, void *); |
|
2321 |
} |
|
2322 |
||
2323 |
jint JvmtiExport::load_agent_library(AttachOperation* op, outputStream* st) { |
|
36188
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2324 |
// get agent name and options |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2325 |
const char* agent = op->arg(0); |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2326 |
const char* absParam = op->arg(1); |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2327 |
const char* options = op->arg(2); |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2328 |
|
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2329 |
return load_agent_library(agent, absParam, options, st); |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2330 |
} |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2331 |
|
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2332 |
jint JvmtiExport::load_agent_library(const char *agent, const char *absParam, |
99b6836dd3e8
8147388: Add diagnostic commands to attach JVMTI agent.
ysuenaga
parents:
35492
diff
changeset
|
2333 |
const char *options, outputStream* st) { |
1 | 2334 |
char ebuf[1024]; |
2335 |
char buffer[JVM_MAXPATHLEN]; |
|
14471
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13728
diff
changeset
|
2336 |
void* library = NULL; |
1 | 2337 |
jint result = JNI_ERR; |
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2338 |
const char *on_attach_symbols[] = AGENT_ONATTACH_SYMBOLS; |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2339 |
size_t num_symbol_entries = ARRAY_SIZE(on_attach_symbols); |
1 | 2340 |
|
2341 |
// The abs paramter should be "true" or "false" |
|
2342 |
bool is_absolute_path = (absParam != NULL) && (strcmp(absParam,"true")==0); |
|
2343 |
||
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2344 |
// Initially marked as invalid. It will be set to valid if we can find the agent |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2345 |
AgentLibrary *agent_lib = new AgentLibrary(agent, options, is_absolute_path, NULL); |
1 | 2346 |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2347 |
// Check for statically linked in agent. If not found then if the path is |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2348 |
// absolute we attempt to load the library. Otherwise we try to load it |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2349 |
// from the standard dll directory. |
1 | 2350 |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2351 |
if (!os::find_builtin_agent(agent_lib, on_attach_symbols, num_symbol_entries)) { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2352 |
if (is_absolute_path) { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2353 |
library = os::dll_load(agent, ebuf, sizeof ebuf); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2354 |
} else { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2355 |
// Try to load the agent from the standard dll directory |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2356 |
if (os::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2357 |
agent)) { |
14471
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13728
diff
changeset
|
2358 |
library = os::dll_load(buffer, ebuf, sizeof ebuf); |
f3a6b82e25cf
8001185: parsing of sun.boot.library.path in os::dll_build_name somewhat broken
bpittore
parents:
13728
diff
changeset
|
2359 |
} |
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2360 |
if (library == NULL) { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2361 |
// not found - try local path |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2362 |
char ns[1] = {0}; |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2363 |
if (os::dll_build_name(buffer, sizeof(buffer), ns, agent)) { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2364 |
library = os::dll_load(buffer, ebuf, sizeof ebuf); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2365 |
} |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2366 |
} |
1 | 2367 |
} |
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2368 |
if (library != NULL) { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2369 |
agent_lib->set_os_lib(library); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2370 |
agent_lib->set_valid(); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2371 |
} |
1 | 2372 |
} |
2373 |
// If the library was loaded then we attempt to invoke the Agent_OnAttach |
|
2374 |
// function |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2375 |
if (agent_lib->valid()) { |
1 | 2376 |
// Lookup the Agent_OnAttach function |
2377 |
OnAttachEntry_t on_attach_entry = NULL; |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2378 |
on_attach_entry = CAST_TO_FN_PTR(OnAttachEntry_t, |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2379 |
os::find_agent_function(agent_lib, false, on_attach_symbols, num_symbol_entries)); |
1 | 2380 |
if (on_attach_entry == NULL) { |
2381 |
// Agent_OnAttach missing - unload library |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2382 |
if (!agent_lib->is_static_lib()) { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2383 |
os::dll_unload(library); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2384 |
} |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2385 |
delete agent_lib; |
1 | 2386 |
} else { |
2387 |
// Invoke the Agent_OnAttach function |
|
2388 |
JavaThread* THREAD = JavaThread::current(); |
|
2389 |
{ |
|
2390 |
extern struct JavaVM_ main_vm; |
|
2391 |
JvmtiThreadEventMark jem(THREAD); |
|
2392 |
JvmtiJavaThreadEventTransition jet(THREAD); |
|
2393 |
||
2394 |
result = (*on_attach_entry)(&main_vm, (char*)options, NULL); |
|
2395 |
} |
|
2396 |
||
2397 |
// Agent_OnAttach may have used JNI |
|
2398 |
if (HAS_PENDING_EXCEPTION) { |
|
2399 |
CLEAR_PENDING_EXCEPTION; |
|
2400 |
} |
|
2401 |
||
2402 |
// If OnAttach returns JNI_OK then we add it to the list of |
|
2403 |
// agent libraries so that we can call Agent_OnUnload later. |
|
2404 |
if (result == JNI_OK) { |
|
19553
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2405 |
Arguments::add_loaded_agent(agent_lib); |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2406 |
} else { |
9bbd930be684
8014135: The JVMTI specification does not conform to recent changes in JNI specification
bpittore
parents:
18940
diff
changeset
|
2407 |
delete agent_lib; |
1 | 2408 |
} |
2409 |
||
2410 |
st->print_cr("%d", result); |
|
2411 |
} |
|
2412 |
} |
|
2413 |
return result; |
|
2414 |
} |
|
2415 |
||
37195
88b6f1271f64
8151991: jvmti diagnostics commands requires INCLUDE_SERVICES
dsamersoff
parents:
36508
diff
changeset
|
2416 |
#endif // INCLUDE_SERVICES |
1 | 2417 |
//////////////////////////////////////////////////////////////////////////////////////////////// |
2418 |
||
2419 |
// Setup current current thread for event collection. |
|
2420 |
void JvmtiEventCollector::setup_jvmti_thread_state() { |
|
2421 |
// set this event collector to be the current one. |
|
2422 |
JvmtiThreadState* state = JvmtiThreadState::state_for(JavaThread::current()); |
|
2135
f82c3012ec86
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
1374
diff
changeset
|
2423 |
// state can only be NULL if the current thread is exiting which |
f82c3012ec86
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
1374
diff
changeset
|
2424 |
// should not happen since we're trying to configure for event collection |
f82c3012ec86
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
1374
diff
changeset
|
2425 |
guarantee(state != NULL, "exiting thread called setup_jvmti_thread_state"); |
1 | 2426 |
if (is_vm_object_alloc_event()) { |
2427 |
_prev = state->get_vm_object_alloc_event_collector(); |
|
2428 |
state->set_vm_object_alloc_event_collector((JvmtiVMObjectAllocEventCollector *)this); |
|
2429 |
} else if (is_dynamic_code_event()) { |
|
2430 |
_prev = state->get_dynamic_code_event_collector(); |
|
2431 |
state->set_dynamic_code_event_collector((JvmtiDynamicCodeEventCollector *)this); |
|
2432 |
} |
|
2433 |
} |
|
2434 |
||
2435 |
// Unset current event collection in this thread and reset it with previous |
|
2436 |
// collector. |
|
2437 |
void JvmtiEventCollector::unset_jvmti_thread_state() { |
|
2438 |
JvmtiThreadState* state = JavaThread::current()->jvmti_thread_state(); |
|
2439 |
if (state != NULL) { |
|
2440 |
// restore the previous event collector (if any) |
|
2441 |
if (is_vm_object_alloc_event()) { |
|
2442 |
if (state->get_vm_object_alloc_event_collector() == this) { |
|
2443 |
state->set_vm_object_alloc_event_collector((JvmtiVMObjectAllocEventCollector *)_prev); |
|
2444 |
} else { |
|
2445 |
// this thread's jvmti state was created during the scope of |
|
2446 |
// the event collector. |
|
2447 |
} |
|
2448 |
} else { |
|
2449 |
if (is_dynamic_code_event()) { |
|
2450 |
if (state->get_dynamic_code_event_collector() == this) { |
|
2451 |
state->set_dynamic_code_event_collector((JvmtiDynamicCodeEventCollector *)_prev); |
|
2452 |
} else { |
|
2453 |
// this thread's jvmti state was created during the scope of |
|
2454 |
// the event collector. |
|
2455 |
} |
|
2456 |
} |
|
2457 |
} |
|
2458 |
} |
|
2459 |
} |
|
2460 |
||
2461 |
// create the dynamic code event collector |
|
2462 |
JvmtiDynamicCodeEventCollector::JvmtiDynamicCodeEventCollector() : _code_blobs(NULL) { |
|
2463 |
if (JvmtiExport::should_post_dynamic_code_generated()) { |
|
2464 |
setup_jvmti_thread_state(); |
|
2465 |
} |
|
2466 |
} |
|
2467 |
||
2468 |
// iterate over any code blob descriptors collected and post a |
|
2469 |
// DYNAMIC_CODE_GENERATED event to the profiler. |
|
2470 |
JvmtiDynamicCodeEventCollector::~JvmtiDynamicCodeEventCollector() { |
|
2471 |
assert(!JavaThread::current()->owns_locks(), "all locks must be released to post deferred events"); |
|
2472 |
// iterate over any code blob descriptors that we collected |
|
2473 |
if (_code_blobs != NULL) { |
|
2474 |
for (int i=0; i<_code_blobs->length(); i++) { |
|
2475 |
JvmtiCodeBlobDesc* blob = _code_blobs->at(i); |
|
2476 |
JvmtiExport::post_dynamic_code_generated(blob->name(), blob->code_begin(), blob->code_end()); |
|
2477 |
FreeHeap(blob); |
|
2478 |
} |
|
2479 |
delete _code_blobs; |
|
2480 |
} |
|
2481 |
unset_jvmti_thread_state(); |
|
2482 |
} |
|
2483 |
||
2484 |
// register a stub |
|
2485 |
void JvmtiDynamicCodeEventCollector::register_stub(const char* name, address start, address end) { |
|
2486 |
if (_code_blobs == NULL) { |
|
13195 | 2487 |
_code_blobs = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JvmtiCodeBlobDesc*>(1,true); |
1 | 2488 |
} |
2489 |
_code_blobs->append(new JvmtiCodeBlobDesc(name, start, end)); |
|
2490 |
} |
|
2491 |
||
2492 |
// Setup current thread to record vm allocated objects. |
|
2493 |
JvmtiVMObjectAllocEventCollector::JvmtiVMObjectAllocEventCollector() : _allocated(NULL) { |
|
2494 |
if (JvmtiExport::should_post_vm_object_alloc()) { |
|
2495 |
_enable = true; |
|
2496 |
setup_jvmti_thread_state(); |
|
2497 |
} else { |
|
2498 |
_enable = false; |
|
2499 |
} |
|
2500 |
} |
|
2501 |
||
2502 |
// Post vm_object_alloc event for vm allocated objects visible to java |
|
2503 |
// world. |
|
2504 |
JvmtiVMObjectAllocEventCollector::~JvmtiVMObjectAllocEventCollector() { |
|
2505 |
if (_allocated != NULL) { |
|
2506 |
set_enabled(false); |
|
2507 |
for (int i = 0; i < _allocated->length(); i++) { |
|
2508 |
oop obj = _allocated->at(i); |
|
2509 |
if (ServiceUtil::visible_oop(obj)) { |
|
2510 |
JvmtiExport::post_vm_object_alloc(JavaThread::current(), obj); |
|
2511 |
} |
|
2512 |
} |
|
2513 |
delete _allocated; |
|
2514 |
} |
|
2515 |
unset_jvmti_thread_state(); |
|
2516 |
} |
|
2517 |
||
2518 |
void JvmtiVMObjectAllocEventCollector::record_allocation(oop obj) { |
|
2519 |
assert(is_enabled(), "VM object alloc event collector is not enabled"); |
|
2520 |
if (_allocated == NULL) { |
|
13195 | 2521 |
_allocated = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<oop>(1, true); |
1 | 2522 |
} |
2523 |
_allocated->push(obj); |
|
2524 |
} |
|
2525 |
||
2526 |
// GC support. |
|
2527 |
void JvmtiVMObjectAllocEventCollector::oops_do(OopClosure* f) { |
|
2528 |
if (_allocated != NULL) { |
|
2529 |
for(int i=_allocated->length() - 1; i >= 0; i--) { |
|
2530 |
if (_allocated->at(i) != NULL) { |
|
2531 |
f->do_oop(_allocated->adr_at(i)); |
|
2532 |
} |
|
2533 |
} |
|
2534 |
} |
|
2535 |
} |
|
2536 |
||
2537 |
void JvmtiVMObjectAllocEventCollector::oops_do_for_all_threads(OopClosure* f) { |
|
2538 |
// no-op if jvmti not enabled |
|
2539 |
if (!JvmtiEnv::environments_might_exist()) { |
|
2540 |
return; |
|
2541 |
} |
|
2542 |
||
2543 |
// Runs at safepoint. So no need to acquire Threads_lock. |
|
2544 |
for (JavaThread *jthr = Threads::first(); jthr != NULL; jthr = jthr->next()) { |
|
2545 |
JvmtiThreadState *state = jthr->jvmti_thread_state(); |
|
2546 |
if (state != NULL) { |
|
2547 |
JvmtiVMObjectAllocEventCollector *collector; |
|
2548 |
collector = state->get_vm_object_alloc_event_collector(); |
|
2549 |
while (collector != NULL) { |
|
2550 |
collector->oops_do(f); |
|
2551 |
collector = (JvmtiVMObjectAllocEventCollector *)collector->get_prev(); |
|
2552 |
} |
|
2553 |
} |
|
2554 |
} |
|
2555 |
} |
|
2556 |
||
2557 |
||
2558 |
// Disable collection of VMObjectAlloc events |
|
2559 |
NoJvmtiVMObjectAllocMark::NoJvmtiVMObjectAllocMark() : _collector(NULL) { |
|
2560 |
// a no-op if VMObjectAlloc event is not enabled |
|
2561 |
if (!JvmtiExport::should_post_vm_object_alloc()) { |
|
2562 |
return; |
|
2563 |
} |
|
34633
2a6c7c7b30a7
8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents:
33148
diff
changeset
|
2564 |
Thread* thread = Thread::current_or_null(); |
1 | 2565 |
if (thread != NULL && thread->is_Java_thread()) { |
2566 |
JavaThread* current_thread = (JavaThread*)thread; |
|
2567 |
JvmtiThreadState *state = current_thread->jvmti_thread_state(); |
|
2568 |
if (state != NULL) { |
|
2569 |
JvmtiVMObjectAllocEventCollector *collector; |
|
2570 |
collector = state->get_vm_object_alloc_event_collector(); |
|
2571 |
if (collector != NULL && collector->is_enabled()) { |
|
2572 |
_collector = collector; |
|
2573 |
_collector->set_enabled(false); |
|
2574 |
} |
|
2575 |
} |
|
2576 |
} |
|
2577 |
} |
|
2578 |
||
2579 |
// Re-Enable collection of VMObjectAlloc events (if previously enabled) |
|
2580 |
NoJvmtiVMObjectAllocMark::~NoJvmtiVMObjectAllocMark() { |
|
2581 |
if (was_enabled()) { |
|
2582 |
_collector->set_enabled(true); |
|
2583 |
} |
|
2584 |
}; |
|
2585 |
||
7896
08aadd7aa3ee
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
7413
diff
changeset
|
2586 |
JvmtiGCMarker::JvmtiGCMarker() { |
1 | 2587 |
// if there aren't any JVMTI environments then nothing to do |
2588 |
if (!JvmtiEnv::environments_might_exist()) { |
|
2589 |
return; |
|
2590 |
} |
|
2591 |
||
2592 |
if (JvmtiExport::should_post_garbage_collection_start()) { |
|
2593 |
JvmtiExport::post_garbage_collection_start(); |
|
2594 |
} |
|
2595 |
||
7896
08aadd7aa3ee
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
7413
diff
changeset
|
2596 |
if (SafepointSynchronize::is_at_safepoint()) { |
08aadd7aa3ee
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
7413
diff
changeset
|
2597 |
// Do clean up tasks that need to be done at a safepoint |
08aadd7aa3ee
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
7413
diff
changeset
|
2598 |
JvmtiEnvBase::check_for_periodic_clean_up(); |
1 | 2599 |
} |
2600 |
} |
|
2601 |
||
2602 |
JvmtiGCMarker::~JvmtiGCMarker() { |
|
2603 |
// if there aren't any JVMTI environments then nothing to do |
|
2604 |
if (!JvmtiEnv::environments_might_exist()) { |
|
2605 |
return; |
|
2606 |
} |
|
2607 |
||
2608 |
// JVMTI notify gc finish |
|
2609 |
if (JvmtiExport::should_post_garbage_collection_finish()) { |
|
2610 |
JvmtiExport::post_garbage_collection_finish(); |
|
2611 |
} |
|
2612 |
} |