1 /* Copyright (C) 2016 The Android Open Source Project 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This file implements interfaces from the file jvmti.h. This implementation 5 * is licensed under the same terms as the file jvmti.h. The 6 * copyright and license information for the file jvmti.h follows. 7 * 8 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. 9 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 10 * 11 * This code is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License version 2 only, as 13 * published by the Free Software Foundation. Oracle designates this 14 * particular file as subject to the "Classpath" exception as provided 15 * by Oracle in the LICENSE file that accompanied this code. 16 * 17 * This code is distributed in the hope that it will be useful, but WITHOUT 18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 20 * version 2 for more details (a copy is included in the LICENSE file that 21 * accompanied this code). 22 * 23 * You should have received a copy of the GNU General Public License version 24 * 2 along with this work; if not, write to the Free Software Foundation, 25 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 26 * 27 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 28 * or visit www.oracle.com if you need additional information or have any 29 * questions. 30 */ 31 32 #ifndef ART_OPENJDKJVMTI_ART_JVMTI_H_ 33 #define ART_OPENJDKJVMTI_ART_JVMTI_H_ 34 35 #include <memory> 36 #include <type_traits> 37 #include <unordered_map> 38 #include <unordered_set> 39 40 #include <jni.h> 41 42 #include <android-base/logging.h> 43 44 #include "deopt_manager.h" 45 #include "base/casts.h" 46 #include "base/macros.h" 47 #include "base/strlcpy.h" 48 #include "base/mutex.h" 49 #include "events.h" 50 #include "jni/java_vm_ext.h" 51 #include "jni/jni_env_ext.h" 52 #include "jvmti.h" 53 #include "ti_breakpoint.h" 54 55 namespace art { 56 class ArtField; 57 class ArtMethod; 58 class ShadowFrame; 59 } // namespace art 60 61 namespace openjdkjvmti { 62 63 class ObjectTagTable; 64 65 // A special version that we use to identify special tooling interface versions which mostly matches 66 // the jvmti spec but everything is best effort. This is used to implement the userdebug 67 // 'debug-anything' behavior. 68 // 69 // This is the value 0x70010200. 70 static constexpr jint kArtTiVersion = JVMTI_VERSION_1_2 | 0x40000000; 71 72 // A structure that is a jvmtiEnv with additional information for the runtime. 73 struct ArtJvmTiEnv : public jvmtiEnv { 74 art::JavaVMExt* art_vm; 75 void* local_data; 76 77 // The ti_version we are compatible with. This is only for giving the correct value for GetVersion 78 // when running on a userdebug/eng device. 79 jint ti_version; 80 81 jvmtiCapabilities capabilities; 82 83 EventMasks event_masks; 84 std::unique_ptr<ArtJvmtiEventCallbacks> event_callbacks; 85 86 // Tagging is specific to the jvmtiEnv. 87 std::unique_ptr<ObjectTagTable> object_tag_table; 88 89 // Set of watched fields is unique to each jvmtiEnv. 90 // TODO It might be good to follow the RI and only let one jvmtiEnv ever have the watch caps so 91 // we can record this on the field directly. We could do this either using free access-flag bits 92 // or by putting a list in the ClassExt of a field's DeclaringClass. 93 // TODO Maybe just have an extension to let one put a watch on every field, that would probably be 94 // good enough maybe since you probably want either a few or all/almost all of them. 95 std::unordered_set<art::ArtField*> access_watched_fields GUARDED_BY(event_info_mutex_); 96 std::unordered_set<art::ArtField*> modify_watched_fields GUARDED_BY(event_info_mutex_); 97 98 // Set of breakpoints is unique to each jvmtiEnv. 99 std::unordered_set<Breakpoint> breakpoints GUARDED_BY(event_info_mutex_); 100 std::unordered_set<const art::ShadowFrame*> notify_frames GUARDED_BY(event_info_mutex_); 101 102 // RW lock to protect access to all of the event data. 103 art::ReaderWriterMutex event_info_mutex_ DEFAULT_MUTEX_ACQUIRED_AFTER; 104 105 std::string last_error_ GUARDED_BY(last_error_mutex_); 106 // Lock to touch the last-error-message. 107 art::Mutex last_error_mutex_ BOTTOM_MUTEX_ACQUIRED_AFTER; 108 109 ArtJvmTiEnv(art::JavaVMExt* runtime, EventHandler* event_handler, jint ti_version); 110 111 static ArtJvmTiEnv* AsArtJvmTiEnv(jvmtiEnv* env) { 112 return art::down_cast<ArtJvmTiEnv*>(env); 113 } 114 115 // Top level lock. Nothing can be held when we get this except for mutator lock for full 116 // thread-suspension. 117 static art::Mutex *gEnvMutex ACQUIRED_AFTER(art::Locks::mutator_lock_); 118 }; 119 120 // Macro and constexpr to make error values less annoying to write. 121 #define ERR(e) JVMTI_ERROR_ ## e 122 static constexpr jvmtiError OK = JVMTI_ERROR_NONE; 123 124 // Special error code for unimplemented functions in JVMTI 125 static constexpr jvmtiError ERR(NOT_IMPLEMENTED) = JVMTI_ERROR_NOT_AVAILABLE; 126 127 static inline JNIEnv* GetJniEnv(jvmtiEnv* env) { 128 JNIEnv* ret_value = nullptr; 129 jint res = reinterpret_cast<ArtJvmTiEnv*>(env)->art_vm->GetEnv( 130 reinterpret_cast<void**>(&ret_value), JNI_VERSION_1_1); 131 if (res != JNI_OK) { 132 return nullptr; 133 } 134 return ret_value; 135 } 136 137 template <typename T> 138 class JvmtiDeleter { 139 public: 140 JvmtiDeleter() : env_(nullptr) {} 141 explicit JvmtiDeleter(jvmtiEnv* env) : env_(env) {} 142 143 JvmtiDeleter(JvmtiDeleter&) = default; 144 JvmtiDeleter(JvmtiDeleter&&) = default; 145 JvmtiDeleter& operator=(const JvmtiDeleter&) = default; 146 147 void operator()(T* ptr) const { 148 CHECK(env_ != nullptr); 149 jvmtiError ret = env_->Deallocate(reinterpret_cast<unsigned char*>(ptr)); 150 CHECK(ret == ERR(NONE)); 151 } 152 153 private: 154 mutable jvmtiEnv* env_; 155 }; 156 157 template <typename T> 158 class JvmtiDeleter<T[]> { 159 public: 160 JvmtiDeleter() : env_(nullptr) {} 161 explicit JvmtiDeleter(jvmtiEnv* env) : env_(env) {} 162 163 JvmtiDeleter(JvmtiDeleter&) = default; 164 JvmtiDeleter(JvmtiDeleter&&) = default; 165 JvmtiDeleter& operator=(const JvmtiDeleter&) = default; 166 167 template <typename U> 168 void operator()(U* ptr) const { 169 CHECK(env_ != nullptr); 170 jvmtiError ret = env_->Deallocate(reinterpret_cast<unsigned char*>(ptr)); 171 CHECK(ret == ERR(NONE)); 172 } 173 174 private: 175 mutable jvmtiEnv* env_; 176 }; 177 178 template <typename T> 179 using JvmtiUniquePtr = std::unique_ptr<T, JvmtiDeleter<T>>; 180 181 template <typename T> 182 ALWAYS_INLINE 183 static inline JvmtiUniquePtr<T> MakeJvmtiUniquePtr(jvmtiEnv* env, T* mem) { 184 return JvmtiUniquePtr<T>(mem, JvmtiDeleter<T>(env)); 185 } 186 187 template <typename T> 188 ALWAYS_INLINE 189 static inline JvmtiUniquePtr<T> MakeJvmtiUniquePtr(jvmtiEnv* env, unsigned char* mem) { 190 return JvmtiUniquePtr<T>(reinterpret_cast<T*>(mem), JvmtiDeleter<T>(env)); 191 } 192 193 template <typename T> 194 ALWAYS_INLINE 195 static inline JvmtiUniquePtr<T> AllocJvmtiUniquePtr(jvmtiEnv* env, jvmtiError* error) { 196 unsigned char* tmp; 197 *error = env->Allocate(sizeof(T), &tmp); 198 if (*error != ERR(NONE)) { 199 return JvmtiUniquePtr<T>(); 200 } 201 return JvmtiUniquePtr<T>(tmp, JvmtiDeleter<T>(env)); 202 } 203 204 template <typename T> 205 ALWAYS_INLINE 206 static inline JvmtiUniquePtr<T> AllocJvmtiUniquePtr(jvmtiEnv* env, 207 size_t count, 208 jvmtiError* error) { 209 unsigned char* tmp; 210 *error = env->Allocate(sizeof(typename std::remove_extent<T>::type) * count, &tmp); 211 if (*error != ERR(NONE)) { 212 return JvmtiUniquePtr<T>(); 213 } 214 return JvmtiUniquePtr<T>(reinterpret_cast<typename std::remove_extent<T>::type*>(tmp), 215 JvmtiDeleter<T>(env)); 216 } 217 218 ALWAYS_INLINE 219 static inline jvmtiError CopyDataIntoJvmtiBuffer(ArtJvmTiEnv* env, 220 const unsigned char* source, 221 jint len, 222 /*out*/unsigned char** dest) { 223 jvmtiError res = env->Allocate(len, dest); 224 if (res != OK) { 225 return res; 226 } 227 memcpy(reinterpret_cast<void*>(*dest), 228 reinterpret_cast<const void*>(source), 229 len); 230 return OK; 231 } 232 233 ALWAYS_INLINE 234 static inline JvmtiUniquePtr<char[]> CopyString(jvmtiEnv* env, const char* src, jvmtiError* error) { 235 if (src == nullptr) { 236 JvmtiUniquePtr<char[]> ret = AllocJvmtiUniquePtr<char[]>(env, 0, error); 237 return ret; 238 } 239 size_t len = strlen(src) + 1; 240 JvmtiUniquePtr<char[]> ret = AllocJvmtiUniquePtr<char[]>(env, len, error); 241 if (ret != nullptr) { 242 strlcpy(ret.get(), src, len); 243 } 244 return ret; 245 } 246 247 const jvmtiCapabilities kPotentialCapabilities = { 248 .can_tag_objects = 1, 249 .can_generate_field_modification_events = 1, 250 .can_generate_field_access_events = 1, 251 .can_get_bytecodes = 1, 252 .can_get_synthetic_attribute = 1, 253 .can_get_owned_monitor_info = 1, 254 .can_get_current_contended_monitor = 1, 255 .can_get_monitor_info = 1, 256 .can_pop_frame = 1, 257 .can_redefine_classes = 1, 258 .can_signal_thread = 1, 259 .can_get_source_file_name = 1, 260 .can_get_line_numbers = 1, 261 .can_get_source_debug_extension = 1, 262 .can_access_local_variables = 1, 263 .can_maintain_original_method_order = 1, 264 .can_generate_single_step_events = 1, 265 .can_generate_exception_events = 1, 266 .can_generate_frame_pop_events = 1, 267 .can_generate_breakpoint_events = 1, 268 .can_suspend = 1, 269 .can_redefine_any_class = 0, 270 .can_get_current_thread_cpu_time = 0, 271 .can_get_thread_cpu_time = 0, 272 .can_generate_method_entry_events = 1, 273 .can_generate_method_exit_events = 1, 274 .can_generate_all_class_hook_events = 0, 275 .can_generate_compiled_method_load_events = 0, 276 .can_generate_monitor_events = 1, 277 .can_generate_vm_object_alloc_events = 1, 278 .can_generate_native_method_bind_events = 1, 279 .can_generate_garbage_collection_events = 1, 280 .can_generate_object_free_events = 1, 281 .can_force_early_return = 0, 282 .can_get_owned_monitor_stack_depth_info = 1, 283 .can_get_constant_pool = 0, 284 .can_set_native_method_prefix = 0, 285 .can_retransform_classes = 1, 286 .can_retransform_any_class = 0, 287 .can_generate_resource_exhaustion_heap_events = 0, 288 .can_generate_resource_exhaustion_threads_events = 0, 289 }; 290 291 // These are capabilities that are disabled if we were loaded without being debuggable. 292 // 293 // This includes the following capabilities: 294 // can_retransform_any_class: 295 // can_retransform_classes: 296 // can_redefine_any_class: 297 // can_redefine_classes: 298 // can_pop_frame: 299 // We need to ensure that inlined code is either not present or can always be deoptimized. This 300 // is not guaranteed for non-debuggable processes since we might have inlined bootclasspath code 301 // on a threads stack. 302 const jvmtiCapabilities kNonDebuggableUnsupportedCapabilities = { 303 .can_tag_objects = 0, 304 .can_generate_field_modification_events = 0, 305 .can_generate_field_access_events = 0, 306 .can_get_bytecodes = 0, 307 .can_get_synthetic_attribute = 0, 308 .can_get_owned_monitor_info = 0, 309 .can_get_current_contended_monitor = 0, 310 .can_get_monitor_info = 0, 311 .can_pop_frame = 1, 312 .can_redefine_classes = 1, 313 .can_signal_thread = 0, 314 .can_get_source_file_name = 0, 315 .can_get_line_numbers = 0, 316 .can_get_source_debug_extension = 0, 317 .can_access_local_variables = 0, 318 .can_maintain_original_method_order = 0, 319 .can_generate_single_step_events = 0, 320 .can_generate_exception_events = 0, 321 .can_generate_frame_pop_events = 0, 322 .can_generate_breakpoint_events = 0, 323 .can_suspend = 0, 324 .can_redefine_any_class = 1, 325 .can_get_current_thread_cpu_time = 0, 326 .can_get_thread_cpu_time = 0, 327 .can_generate_method_entry_events = 0, 328 .can_generate_method_exit_events = 0, 329 .can_generate_all_class_hook_events = 0, 330 .can_generate_compiled_method_load_events = 0, 331 .can_generate_monitor_events = 0, 332 .can_generate_vm_object_alloc_events = 0, 333 .can_generate_native_method_bind_events = 0, 334 .can_generate_garbage_collection_events = 0, 335 .can_generate_object_free_events = 0, 336 .can_force_early_return = 0, 337 .can_get_owned_monitor_stack_depth_info = 0, 338 .can_get_constant_pool = 0, 339 .can_set_native_method_prefix = 0, 340 .can_retransform_classes = 1, 341 .can_retransform_any_class = 1, 342 .can_generate_resource_exhaustion_heap_events = 0, 343 .can_generate_resource_exhaustion_threads_events = 0, 344 }; 345 346 } // namespace openjdkjvmti 347 348 #endif // ART_OPENJDKJVMTI_ART_JVMTI_H_ 349
