Mercurial > hg > truffle
annotate src/share/vm/prims/jvmtiExport.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | da91efe96a93 |
| children | fb19af007ffc |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
5935
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_PRIMS_JVMTIEXPORT_HPP |
| 26 #define SHARE_VM_PRIMS_JVMTIEXPORT_HPP | |
| 27 | |
| 28 #include "jvmtifiles/jvmti.h" | |
| 29 #include "memory/allocation.hpp" | |
| 30 #include "memory/iterator.hpp" | |
| 31 #include "oops/oop.hpp" | |
| 32 #include "oops/oopsHierarchy.hpp" | |
| 33 #include "runtime/frame.hpp" | |
| 34 #include "runtime/handles.hpp" | |
| 35 #include "utilities/globalDefinitions.hpp" | |
| 36 #include "utilities/growableArray.hpp" | |
| 0 | 37 |
|
1983
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
38 // Must be included after jvmti.h. |
|
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
39 #include "code/jvmticmlr.h" |
|
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
40 |
| 0 | 41 // Forward declarations |
| 42 | |
| 43 class JvmtiEventControllerPrivate; | |
| 44 class JvmtiManageCapabilities; | |
| 45 class JvmtiEnv; | |
| 46 class JvmtiThreadState; | |
| 47 class AttachOperation; | |
| 48 | |
| 49 #ifndef JVMTI_KERNEL | |
| 50 #define JVMTI_SUPPORT_FLAG(key) \ | |
| 51 private: \ | |
| 52 static bool _##key; \ | |
| 53 public: \ | |
| 54 inline static void set_##key(bool on) { _##key = (on != 0); } \ | |
| 55 inline static bool key() { return _##key; } | |
| 56 #else // JVMTI_KERNEL | |
| 57 #define JVMTI_SUPPORT_FLAG(key) \ | |
| 58 private: \ | |
| 59 const static bool _##key = false; \ | |
| 60 public: \ | |
| 61 inline static void set_##key(bool on) { report_unsupported(on); } \ | |
| 62 inline static bool key() { return _##key; } | |
| 63 #endif // JVMTI_KERNEL | |
| 64 | |
| 65 | |
| 66 // This class contains the JVMTI interface for the rest of hotspot. | |
| 67 // | |
| 68 class JvmtiExport : public AllStatic { | |
| 3939 | 69 friend class VMStructs; |
| 0 | 70 private: |
| 71 static int _field_access_count; | |
| 72 static int _field_modification_count; | |
| 73 | |
| 74 static bool _can_access_local_variables; | |
| 75 static bool _can_hotswap_or_post_breakpoint; | |
| 76 static bool _can_modify_any_class; | |
| 77 static bool _can_walk_any_space; | |
| 78 | |
| 79 JVMTI_SUPPORT_FLAG(can_get_source_debug_extension) | |
| 80 JVMTI_SUPPORT_FLAG(can_maintain_original_method_order) | |
| 81 JVMTI_SUPPORT_FLAG(can_post_interpreter_events) | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1121
diff
changeset
|
82 JVMTI_SUPPORT_FLAG(can_post_on_exceptions) |
| 0 | 83 JVMTI_SUPPORT_FLAG(can_post_breakpoint) |
| 84 JVMTI_SUPPORT_FLAG(can_post_field_access) | |
| 85 JVMTI_SUPPORT_FLAG(can_post_field_modification) | |
| 86 JVMTI_SUPPORT_FLAG(can_post_method_entry) | |
| 87 JVMTI_SUPPORT_FLAG(can_post_method_exit) | |
| 88 JVMTI_SUPPORT_FLAG(can_pop_frame) | |
| 89 JVMTI_SUPPORT_FLAG(can_force_early_return) | |
| 90 | |
| 91 friend class JvmtiEventControllerPrivate; // should only modify these flags | |
| 92 JVMTI_SUPPORT_FLAG(should_post_single_step) | |
| 93 JVMTI_SUPPORT_FLAG(should_post_field_access) | |
| 94 JVMTI_SUPPORT_FLAG(should_post_field_modification) | |
| 95 JVMTI_SUPPORT_FLAG(should_post_class_load) | |
| 96 JVMTI_SUPPORT_FLAG(should_post_class_prepare) | |
| 97 JVMTI_SUPPORT_FLAG(should_post_class_unload) | |
| 98 JVMTI_SUPPORT_FLAG(should_post_native_method_bind) | |
| 99 JVMTI_SUPPORT_FLAG(should_post_compiled_method_load) | |
| 100 JVMTI_SUPPORT_FLAG(should_post_compiled_method_unload) | |
| 101 JVMTI_SUPPORT_FLAG(should_post_dynamic_code_generated) | |
| 102 JVMTI_SUPPORT_FLAG(should_post_monitor_contended_enter) | |
| 103 JVMTI_SUPPORT_FLAG(should_post_monitor_contended_entered) | |
| 104 JVMTI_SUPPORT_FLAG(should_post_monitor_wait) | |
| 105 JVMTI_SUPPORT_FLAG(should_post_monitor_waited) | |
| 106 JVMTI_SUPPORT_FLAG(should_post_data_dump) | |
| 107 JVMTI_SUPPORT_FLAG(should_post_garbage_collection_start) | |
| 108 JVMTI_SUPPORT_FLAG(should_post_garbage_collection_finish) | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1121
diff
changeset
|
109 JVMTI_SUPPORT_FLAG(should_post_on_exceptions) |
| 0 | 110 |
| 111 // ------ the below maybe don't have to be (but are for now) | |
| 112 // fixed conditions here ------------ | |
| 113 // any events can be enabled | |
| 114 JVMTI_SUPPORT_FLAG(should_post_thread_life) | |
| 115 JVMTI_SUPPORT_FLAG(should_post_object_free) | |
| 116 JVMTI_SUPPORT_FLAG(should_post_resource_exhausted) | |
| 117 | |
| 118 // we are holding objects on the heap - need to talk to GC - e.g. | |
| 119 // breakpoint info | |
| 120 JVMTI_SUPPORT_FLAG(should_clean_up_heap_objects) | |
| 121 JVMTI_SUPPORT_FLAG(should_post_vm_object_alloc) | |
| 122 | |
| 123 // If flag cannot be implemented, give an error if on=true | |
| 124 static void report_unsupported(bool on); | |
| 125 | |
| 126 // these should only be called by the friend class | |
| 127 friend class JvmtiManageCapabilities; | |
| 128 inline static void set_can_modify_any_class(bool on) { _can_modify_any_class = (on != 0); } | |
| 129 inline static void set_can_access_local_variables(bool on) { _can_access_local_variables = (on != 0); } | |
| 130 inline static void set_can_hotswap_or_post_breakpoint(bool on) { _can_hotswap_or_post_breakpoint = (on != 0); } | |
| 131 inline static void set_can_walk_any_space(bool on) { _can_walk_any_space = (on != 0); } | |
| 132 | |
| 133 enum { | |
| 134 JVMTI_VERSION_MASK = 0x70000000, | |
| 135 JVMTI_VERSION_VALUE = 0x30000000, | |
| 136 JVMDI_VERSION_VALUE = 0x20000000 | |
| 137 }; | |
| 138 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
139 static void post_field_modification(JavaThread *thread, Method* method, address location, |
| 0 | 140 KlassHandle field_klass, Handle object, jfieldID field, |
| 141 char sig_type, jvalue *value); | |
| 142 | |
| 143 | |
| 144 // posts a DynamicCodeGenerated event (internal/private implementation). | |
| 145 // The public post_dynamic_code_generated* functions make use of the | |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
146 // internal implementation. Also called from JvmtiDeferredEvent::post() |
| 0 | 147 static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN; |
| 148 | |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
149 private: |
| 0 | 150 |
| 151 // GenerateEvents support to allow posting of CompiledMethodLoad and | |
| 152 // DynamicCodeGenerated events for a given environment. | |
| 153 friend class JvmtiCodeBlobEvents; | |
| 154 | |
| 155 static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length, | |
| 156 const void *code_begin, const jint map_length, | |
| 157 const jvmtiAddrLocationMap* map) KERNEL_RETURN; | |
| 158 static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin, | |
| 159 const void *code_end) KERNEL_RETURN; | |
| 160 | |
| 161 // The RedefineClasses() API breaks some invariants in the "regular" | |
| 162 // system. For example, there are sanity checks when GC'ing nmethods | |
| 163 // that require the containing class to be unloading. However, when a | |
| 164 // method is redefined, the old method and nmethod can become GC'able | |
| 165 // without the containing class unloading. The state of becoming | |
| 166 // GC'able can be asynchronous to the RedefineClasses() call since | |
| 167 // the old method may still be running and cannot be GC'ed until | |
| 168 // after all old invocations have finished. Additionally, a method | |
| 169 // that has not been redefined may have an nmethod that depends on | |
| 170 // the redefined method. The dependent nmethod will get deopted in | |
| 171 // this case and may also be GC'able without the containing class | |
| 172 // being unloaded. | |
| 173 // | |
| 174 // This flag indicates whether RedefineClasses() has ever redefined | |
| 175 // one or more classes during the lifetime of the VM. The flag should | |
| 176 // only be set by the friend class and can be queried by other sub | |
| 177 // systems as needed to relax invariant checks. | |
| 178 static bool _has_redefined_a_class; | |
| 179 friend class VM_RedefineClasses; | |
| 180 inline static void set_has_redefined_a_class() { | |
| 181 _has_redefined_a_class = true; | |
| 182 } | |
| 183 | |
| 184 // Flag to indicate if the compiler has recorded all dependencies. When the | |
| 185 // can_redefine_classes capability is enabled in the OnLoad phase then the compiler | |
| 186 // records all dependencies from startup. However if the capability is first | |
| 187 // enabled some time later then the dependencies recorded by the compiler | |
| 188 // are incomplete. This flag is used by RedefineClasses to know if the | |
| 189 // dependency information is complete or not. | |
| 190 static bool _all_dependencies_are_recorded; | |
| 191 | |
| 192 public: | |
| 193 inline static bool has_redefined_a_class() { | |
| 194 return _has_redefined_a_class; | |
| 195 } | |
| 196 | |
| 197 inline static bool all_dependencies_are_recorded() { | |
| 198 return _all_dependencies_are_recorded; | |
| 199 } | |
| 200 | |
| 201 inline static void set_all_dependencies_are_recorded(bool on) { | |
| 202 _all_dependencies_are_recorded = (on != 0); | |
| 203 } | |
| 204 | |
| 205 | |
| 206 // let JVMTI know that the JVM_OnLoad code is running | |
| 207 static void enter_onload_phase(); | |
| 208 | |
| 209 // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running) | |
| 210 static void enter_primordial_phase(); | |
| 211 | |
| 212 // let JVMTI know that the VM isn't up yet but JNI is live | |
| 213 static void enter_start_phase(); | |
| 214 | |
| 215 // let JVMTI know that the VM is fully up and running now | |
| 216 static void enter_live_phase(); | |
| 217 | |
| 218 // ------ can_* conditions (below) are set at OnLoad and never changed ------------ | |
| 219 inline static bool can_modify_any_class() { return _can_modify_any_class; } | |
| 220 inline static bool can_access_local_variables() { return _can_access_local_variables; } | |
| 221 inline static bool can_hotswap_or_post_breakpoint() { return _can_hotswap_or_post_breakpoint; } | |
| 222 inline static bool can_walk_any_space() { return _can_walk_any_space; } | |
| 223 | |
| 224 // field access management | |
| 225 static address get_field_access_count_addr(); | |
| 226 | |
| 227 // field modification management | |
| 228 static address get_field_modification_count_addr(); | |
| 229 | |
| 230 // ----------------- | |
| 231 | |
| 232 static bool is_jvmti_version(jint version) { return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE; } | |
| 233 static bool is_jvmdi_version(jint version) { return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE; } | |
| 234 static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version); | |
| 1121 | 235 static void decode_version_values(jint version, int * major, int * minor, |
| 236 int * micro); | |
| 0 | 237 |
| 238 // single stepping management methods | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
239 static void at_single_stepping_point(JavaThread *thread, Method* method, address location) KERNEL_RETURN; |
| 0 | 240 static void expose_single_stepping(JavaThread *thread) KERNEL_RETURN; |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
241 static bool hide_single_stepping(JavaThread *thread) KERNEL_RETURN_(false); |
| 0 | 242 |
| 243 // Methods that notify the debugger that something interesting has happened in the VM. | |
| 244 static void post_vm_start (); | |
| 245 static void post_vm_initialized (); | |
| 246 static void post_vm_death (); | |
| 247 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
248 static void post_single_step (JavaThread *thread, Method* method, address location) KERNEL_RETURN; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
249 static void post_raw_breakpoint (JavaThread *thread, Method* method, address location) KERNEL_RETURN; |
| 0 | 250 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
251 static void post_exception_throw (JavaThread *thread, Method* method, address location, oop exception) KERNEL_RETURN; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
252 static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) KERNEL_RETURN; |
| 0 | 253 |
| 254 static oop jni_GetField_probe (JavaThread *thread, jobject jobj, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
255 oop obj, Klass* klass, jfieldID fieldID, bool is_static) |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
256 KERNEL_RETURN_(NULL); |
| 0 | 257 static oop jni_GetField_probe_nh (JavaThread *thread, jobject jobj, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
258 oop obj, Klass* klass, jfieldID fieldID, bool is_static) |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
259 KERNEL_RETURN_(NULL); |
| 0 | 260 static void post_field_access_by_jni (JavaThread *thread, oop obj, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
261 Klass* klass, jfieldID fieldID, bool is_static) KERNEL_RETURN; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
262 static void post_field_access (JavaThread *thread, Method* method, |
| 0 | 263 address location, KlassHandle field_klass, Handle object, jfieldID field) KERNEL_RETURN; |
| 264 static oop jni_SetField_probe (JavaThread *thread, jobject jobj, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
265 oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type, |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
266 jvalue *value) KERNEL_RETURN_(NULL); |
| 0 | 267 static oop jni_SetField_probe_nh (JavaThread *thread, jobject jobj, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
268 oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type, |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
269 jvalue *value) KERNEL_RETURN_(NULL); |
| 0 | 270 static void post_field_modification_by_jni(JavaThread *thread, oop obj, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
271 Klass* klass, jfieldID fieldID, bool is_static, char sig_type, |
| 0 | 272 jvalue *value); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
273 static void post_raw_field_modification(JavaThread *thread, Method* method, |
| 0 | 274 address location, KlassHandle field_klass, Handle object, jfieldID field, |
| 275 char sig_type, jvalue *value) KERNEL_RETURN; | |
| 276 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
277 static void post_method_entry (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
278 static void post_method_exit (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN; |
| 0 | 279 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
280 static void post_class_load (JavaThread *thread, Klass* klass) KERNEL_RETURN; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
281 static void post_class_unload (Klass* klass) KERNEL_RETURN; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
282 static void post_class_prepare (JavaThread *thread, Klass* klass) KERNEL_RETURN; |
| 0 | 283 |
| 284 static void post_thread_start (JavaThread *thread) KERNEL_RETURN; | |
| 285 static void post_thread_end (JavaThread *thread) KERNEL_RETURN; | |
| 286 | |
| 287 // Support for java.lang.instrument agent loading. | |
| 288 static bool _should_post_class_file_load_hook; | |
| 289 inline static void set_should_post_class_file_load_hook(bool on) { _should_post_class_file_load_hook = on; } | |
| 290 inline static bool should_post_class_file_load_hook() { return _should_post_class_file_load_hook; } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
291 static void post_class_file_load_hook(Symbol* h_name, Handle class_loader, |
| 0 | 292 Handle h_protection_domain, |
| 293 unsigned char **data_ptr, unsigned char **end_ptr, | |
| 294 unsigned char **cached_data_ptr, | |
| 295 jint *cached_length_ptr); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
296 static void post_native_method_bind(Method* method, address* function_ptr) KERNEL_RETURN; |
| 0 | 297 static void post_compiled_method_load(nmethod *nm) KERNEL_RETURN; |
| 298 static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN; | |
| 299 | |
|
1577
852d0157c696
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
1397
diff
changeset
|
300 // used to post a CompiledMethodUnload event |
|
852d0157c696
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
1397
diff
changeset
|
301 static void post_compiled_method_unload(jmethodID mid, const void *code_begin) KERNEL_RETURN; |
| 0 | 302 |
| 303 // similiar to post_dynamic_code_generated except that it can be used to | |
| 304 // post a DynamicCodeGenerated event while holding locks in the VM. Any event | |
| 305 // posted using this function is recorded by the enclosing event collector | |
| 306 // -- JvmtiDynamicCodeEventCollector. | |
| 307 static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) KERNEL_RETURN; | |
| 308 | |
| 309 static void post_garbage_collection_finish() KERNEL_RETURN; | |
| 310 static void post_garbage_collection_start() KERNEL_RETURN; | |
| 311 static void post_data_dump() KERNEL_RETURN; | |
| 312 static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN; | |
| 313 static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN; | |
| 314 static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) KERNEL_RETURN; | |
| 315 static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) KERNEL_RETURN; | |
| 316 static void post_object_free(JvmtiEnv* env, jlong tag) KERNEL_RETURN; | |
| 317 static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) KERNEL_RETURN; | |
| 318 static void record_vm_internal_object_allocation(oop object) KERNEL_RETURN; | |
| 319 // Post objects collected by vm_object_alloc_event_collector. | |
| 320 static void post_vm_object_alloc(JavaThread *thread, oop object) KERNEL_RETURN; | |
| 321 // Collects vm internal objects for later event posting. | |
| 322 inline static void vm_object_alloc_event_collector(oop object) { | |
| 323 if (should_post_vm_object_alloc()) { | |
| 324 record_vm_internal_object_allocation(object); | |
| 325 } | |
| 326 } | |
|
5935
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
327 inline static void post_array_size_exhausted() { |
|
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
328 if (should_post_resource_exhausted()) { |
|
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
329 post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR, |
|
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
330 "Requested array size exceeds VM limit"); |
|
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
331 } |
|
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
3939
diff
changeset
|
332 } |
| 0 | 333 |
| 334 static void cleanup_thread (JavaThread* thread) KERNEL_RETURN; | |
| 335 | |
| 336 static void oops_do(OopClosure* f) KERNEL_RETURN; | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
337 static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) KERNEL_RETURN; |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
338 static void gc_epilogue() KERNEL_RETURN; |
| 0 | 339 |
| 340 static void transition_pending_onload_raw_monitors() KERNEL_RETURN; | |
| 341 | |
| 342 #ifndef SERVICES_KERNEL | |
| 343 // attach support | |
| 344 static jint load_agent_library(AttachOperation* op, outputStream* out); | |
| 345 #endif // SERVICES_KERNEL | |
| 346 | |
| 347 // SetNativeMethodPrefix support | |
| 348 static char** get_all_native_method_prefixes(int* count_ptr); | |
| 349 }; | |
| 350 | |
| 351 // Support class used by JvmtiDynamicCodeEventCollector and others. It | |
| 352 // describes a single code blob by name and address range. | |
| 6197 | 353 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> { |
| 0 | 354 private: |
| 355 char _name[64]; | |
| 356 address _code_begin; | |
| 357 address _code_end; | |
| 358 | |
| 359 public: | |
| 360 JvmtiCodeBlobDesc(const char *name, address code_begin, address code_end) { | |
| 361 assert(name != NULL, "all code blobs must be named"); | |
| 362 strncpy(_name, name, sizeof(_name)); | |
| 363 _name[sizeof(_name)-1] = '\0'; | |
| 364 _code_begin = code_begin; | |
| 365 _code_end = code_end; | |
| 366 } | |
| 367 char* name() { return _name; } | |
| 368 address code_begin() { return _code_begin; } | |
| 369 address code_end() { return _code_end; } | |
| 370 }; | |
| 371 | |
| 372 // JvmtiEventCollector is a helper class to setup thread for | |
| 373 // event collection. | |
| 374 class JvmtiEventCollector : public StackObj { | |
| 375 private: | |
| 376 JvmtiEventCollector* _prev; // Save previous one to support nested event collector. | |
| 377 | |
| 378 public: | |
| 379 void setup_jvmti_thread_state(); // Set this collector in current thread. | |
| 380 void unset_jvmti_thread_state(); // Reset previous collector in current thread. | |
| 381 virtual bool is_dynamic_code_event() { return false; } | |
| 382 virtual bool is_vm_object_alloc_event(){ return false; } | |
| 383 JvmtiEventCollector *get_prev() { return _prev; } | |
| 384 }; | |
| 385 | |
| 386 // A JvmtiDynamicCodeEventCollector is a helper class for the JvmtiExport | |
| 387 // interface. It collects "dynamic code generated" events that are posted | |
| 388 // while holding locks. When the event collector goes out of scope the | |
| 389 // events will be posted. | |
| 390 // | |
| 391 // Usage :- | |
| 392 // | |
| 393 // { | |
| 394 // JvmtiDynamicCodeEventCollector event_collector; | |
| 395 // : | |
| 396 // { MutexLocker ml(...) | |
| 397 // : | |
| 398 // JvmtiExport::post_dynamic_code_generated_while_holding_locks(...) | |
| 399 // } | |
| 400 // // event collector goes out of scope => post events to profiler. | |
| 401 // } | |
| 402 | |
| 403 class JvmtiDynamicCodeEventCollector : public JvmtiEventCollector { | |
| 404 private: | |
| 405 GrowableArray<JvmtiCodeBlobDesc*>* _code_blobs; // collected code blob events | |
| 406 | |
| 407 friend class JvmtiExport; | |
| 408 void register_stub(const char* name, address start, address end); | |
| 409 | |
| 410 public: | |
| 411 JvmtiDynamicCodeEventCollector() KERNEL_RETURN; | |
| 412 ~JvmtiDynamicCodeEventCollector() KERNEL_RETURN; | |
| 413 bool is_dynamic_code_event() { return true; } | |
| 414 | |
| 415 }; | |
| 416 | |
| 417 // Used to record vm internally allocated object oops and post | |
| 418 // vm object alloc event for objects visible to java world. | |
| 419 // Constructor enables JvmtiThreadState flag and all vm allocated | |
| 420 // objects are recorded in a growable array. When destructor is | |
| 421 // called the vm object alloc event is posted for each objects | |
| 422 // visible to java world. | |
| 423 // See jvm.cpp file for its usage. | |
| 424 // | |
| 425 class JvmtiVMObjectAllocEventCollector : public JvmtiEventCollector { | |
| 426 private: | |
| 427 GrowableArray<oop>* _allocated; // field to record vm internally allocated object oop. | |
| 428 bool _enable; // This flag is enabled in constructor and disabled | |
| 429 // in destructor before posting event. To avoid | |
| 430 // collection of objects allocated while running java code inside | |
| 431 // agent post_vm_object_alloc() event handler. | |
| 432 | |
| 433 //GC support | |
| 434 void oops_do(OopClosure* f); | |
| 435 | |
| 436 friend class JvmtiExport; | |
| 437 // Record vm allocated object oop. | |
| 438 inline void record_allocation(oop obj); | |
| 439 | |
| 440 //GC support | |
| 441 static void oops_do_for_all_threads(OopClosure* f); | |
| 442 | |
| 443 public: | |
| 444 JvmtiVMObjectAllocEventCollector() KERNEL_RETURN; | |
| 445 ~JvmtiVMObjectAllocEventCollector() KERNEL_RETURN; | |
| 446 bool is_vm_object_alloc_event() { return true; } | |
| 447 | |
| 448 bool is_enabled() { return _enable; } | |
| 449 void set_enabled(bool on) { _enable = on; } | |
| 450 }; | |
| 451 | |
| 452 | |
| 453 | |
| 454 // Marker class to disable the posting of VMObjectAlloc events | |
| 455 // within its scope. | |
| 456 // | |
| 457 // Usage :- | |
| 458 // | |
| 459 // { | |
| 460 // NoJvmtiVMObjectAllocMark njm; | |
| 461 // : | |
| 462 // // VMObjAlloc event will not be posted | |
| 463 // JvmtiExport::vm_object_alloc_event_collector(obj); | |
| 464 // : | |
| 465 // } | |
| 466 | |
| 467 class NoJvmtiVMObjectAllocMark : public StackObj { | |
| 468 private: | |
| 469 // enclosing collector if enabled, NULL otherwise | |
| 470 JvmtiVMObjectAllocEventCollector *_collector; | |
| 471 | |
| 472 bool was_enabled() { return _collector != NULL; } | |
| 473 | |
| 474 public: | |
| 475 NoJvmtiVMObjectAllocMark() KERNEL_RETURN; | |
| 476 ~NoJvmtiVMObjectAllocMark() KERNEL_RETURN; | |
| 477 }; | |
| 478 | |
| 479 | |
| 480 // Base class for reporting GC events to JVMTI. | |
| 481 class JvmtiGCMarker : public StackObj { | |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1983
diff
changeset
|
482 public: |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1983
diff
changeset
|
483 JvmtiGCMarker() KERNEL_RETURN; |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1983
diff
changeset
|
484 ~JvmtiGCMarker() KERNEL_RETURN; |
| 0 | 485 }; |
| 486 | |
| 487 // JvmtiHideSingleStepping is a helper class for hiding | |
| 488 // internal single step events. | |
| 489 class JvmtiHideSingleStepping : public StackObj { | |
| 490 private: | |
| 491 bool _single_step_hidden; | |
| 492 JavaThread * _thread; | |
| 493 | |
| 494 public: | |
| 495 JvmtiHideSingleStepping(JavaThread * thread) { | |
| 496 assert(thread != NULL, "sanity check"); | |
| 497 | |
| 498 _single_step_hidden = false; | |
| 499 _thread = thread; | |
| 500 if (JvmtiExport::should_post_single_step()) { | |
| 501 _single_step_hidden = JvmtiExport::hide_single_stepping(_thread); | |
| 502 } | |
| 503 } | |
| 504 | |
| 505 ~JvmtiHideSingleStepping() { | |
| 506 if (_single_step_hidden) { | |
| 507 JvmtiExport::expose_single_stepping(_thread); | |
| 508 } | |
| 509 } | |
| 510 }; | |
| 511 | |
| 1972 | 512 #endif // SHARE_VM_PRIMS_JVMTIEXPORT_HPP |