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_RUNTIME_OPENJDKJVMTI_ART_JVMTI_H_ 33 #define ART_RUNTIME_OPENJDKJVMTI_ART_JVMTI_H_ 34 35 #include <memory> 36 #include <type_traits> 37 38 #include <jni.h> 39 40 #include "base/array_slice.h" 41 #include "base/casts.h" 42 #include "base/logging.h" 43 #include "base/macros.h" 44 #include "events.h" 45 #include "java_vm_ext.h" 46 #include "jni_env_ext.h" 47 #include "jvmti.h" 48 49 namespace openjdkjvmti { 50 51 class ObjectTagTable; 52 53 // A structure that is a jvmtiEnv with additional information for the runtime. 54 struct ArtJvmTiEnv : public jvmtiEnv { 55 art::JavaVMExt* art_vm; 56 void* local_data; 57 jvmtiCapabilities capabilities; 58 59 EventMasks event_masks; 60 std::unique_ptr<jvmtiEventCallbacks> event_callbacks; 61 62 // Tagging is specific to the jvmtiEnv. 63 std::unique_ptr<ObjectTagTable> object_tag_table; 64 65 ArtJvmTiEnv(art::JavaVMExt* runtime, EventHandler* event_handler); 66 67 static ArtJvmTiEnv* AsArtJvmTiEnv(jvmtiEnv* env) { 68 return art::down_cast<ArtJvmTiEnv*>(env); 69 } 70 }; 71 72 // Macro and constexpr to make error values less annoying to write. 73 #define ERR(e) JVMTI_ERROR_ ## e 74 static constexpr jvmtiError OK = JVMTI_ERROR_NONE; 75 76 // Special error code for unimplemented functions in JVMTI 77 static constexpr jvmtiError ERR(NOT_IMPLEMENTED) = JVMTI_ERROR_NOT_AVAILABLE; 78 79 static inline JNIEnv* GetJniEnv(jvmtiEnv* env) { 80 JNIEnv* ret_value = nullptr; 81 jint res = reinterpret_cast<ArtJvmTiEnv*>(env)->art_vm->GetEnv( 82 reinterpret_cast<void**>(&ret_value), JNI_VERSION_1_1); 83 if (res != JNI_OK) { 84 return nullptr; 85 } 86 return ret_value; 87 } 88 89 template <typename T> 90 class JvmtiDeleter { 91 public: 92 JvmtiDeleter() : env_(nullptr) {} 93 explicit JvmtiDeleter(jvmtiEnv* env) : env_(env) {} 94 95 JvmtiDeleter(JvmtiDeleter&) = default; 96 JvmtiDeleter(JvmtiDeleter&&) = default; 97 JvmtiDeleter& operator=(const JvmtiDeleter&) = default; 98 99 void operator()(T* ptr) const { 100 CHECK(env_ != nullptr); 101 jvmtiError ret = env_->Deallocate(reinterpret_cast<unsigned char*>(ptr)); 102 CHECK(ret == ERR(NONE)); 103 } 104 105 private: 106 mutable jvmtiEnv* env_; 107 }; 108 109 template <typename T> 110 class JvmtiDeleter<T[]> { 111 public: 112 JvmtiDeleter() : env_(nullptr) {} 113 explicit JvmtiDeleter(jvmtiEnv* env) : env_(env) {} 114 115 JvmtiDeleter(JvmtiDeleter&) = default; 116 JvmtiDeleter(JvmtiDeleter&&) = default; 117 JvmtiDeleter& operator=(const JvmtiDeleter&) = default; 118 119 template <typename U> 120 void operator()(U* ptr) const { 121 CHECK(env_ != nullptr); 122 jvmtiError ret = env_->Deallocate(reinterpret_cast<unsigned char*>(ptr)); 123 CHECK(ret == ERR(NONE)); 124 } 125 126 private: 127 mutable jvmtiEnv* env_; 128 }; 129 130 template <typename T> 131 using JvmtiUniquePtr = std::unique_ptr<T, JvmtiDeleter<T>>; 132 133 template <typename T> 134 ALWAYS_INLINE 135 static inline JvmtiUniquePtr<T> MakeJvmtiUniquePtr(jvmtiEnv* env, T* mem) { 136 return JvmtiUniquePtr<T>(mem, JvmtiDeleter<T>(env)); 137 } 138 139 template <typename T> 140 ALWAYS_INLINE 141 static inline JvmtiUniquePtr<T> MakeJvmtiUniquePtr(jvmtiEnv* env, unsigned char* mem) { 142 return JvmtiUniquePtr<T>(reinterpret_cast<T*>(mem), JvmtiDeleter<T>(env)); 143 } 144 145 template <typename T> 146 ALWAYS_INLINE 147 static inline JvmtiUniquePtr<T> AllocJvmtiUniquePtr(jvmtiEnv* env, jvmtiError* error) { 148 unsigned char* tmp; 149 *error = env->Allocate(sizeof(T), &tmp); 150 if (*error != ERR(NONE)) { 151 return JvmtiUniquePtr<T>(); 152 } 153 return JvmtiUniquePtr<T>(tmp, JvmtiDeleter<T>(env)); 154 } 155 156 template <typename T> 157 ALWAYS_INLINE 158 static inline JvmtiUniquePtr<T> AllocJvmtiUniquePtr(jvmtiEnv* env, 159 size_t count, 160 jvmtiError* error) { 161 unsigned char* tmp; 162 *error = env->Allocate(sizeof(typename std::remove_extent<T>::type) * count, &tmp); 163 if (*error != ERR(NONE)) { 164 return JvmtiUniquePtr<T>(); 165 } 166 return JvmtiUniquePtr<T>(reinterpret_cast<typename std::remove_extent<T>::type*>(tmp), 167 JvmtiDeleter<T>(env)); 168 } 169 170 ALWAYS_INLINE 171 static inline jvmtiError CopyDataIntoJvmtiBuffer(ArtJvmTiEnv* env, 172 const unsigned char* source, 173 jint len, 174 /*out*/unsigned char** dest) { 175 jvmtiError res = env->Allocate(len, dest); 176 if (res != OK) { 177 return res; 178 } 179 memcpy(reinterpret_cast<void*>(*dest), 180 reinterpret_cast<const void*>(source), 181 len); 182 return OK; 183 } 184 185 ALWAYS_INLINE 186 static inline JvmtiUniquePtr<char[]> CopyString(jvmtiEnv* env, const char* src, jvmtiError* error) { 187 size_t len = strlen(src) + 1; 188 JvmtiUniquePtr<char[]> ret = AllocJvmtiUniquePtr<char[]>(env, len, error); 189 if (ret != nullptr) { 190 strcpy(ret.get(), src); 191 } 192 return ret; 193 } 194 195 const jvmtiCapabilities kPotentialCapabilities = { 196 .can_tag_objects = 1, 197 .can_generate_field_modification_events = 0, 198 .can_generate_field_access_events = 0, 199 .can_get_bytecodes = 0, 200 .can_get_synthetic_attribute = 1, 201 .can_get_owned_monitor_info = 0, 202 .can_get_current_contended_monitor = 0, 203 .can_get_monitor_info = 0, 204 .can_pop_frame = 0, 205 .can_redefine_classes = 1, 206 .can_signal_thread = 0, 207 .can_get_source_file_name = 0, 208 .can_get_line_numbers = 1, 209 .can_get_source_debug_extension = 0, 210 .can_access_local_variables = 0, 211 .can_maintain_original_method_order = 0, 212 .can_generate_single_step_events = 0, 213 .can_generate_exception_events = 0, 214 .can_generate_frame_pop_events = 0, 215 .can_generate_breakpoint_events = 0, 216 .can_suspend = 0, 217 .can_redefine_any_class = 0, 218 .can_get_current_thread_cpu_time = 0, 219 .can_get_thread_cpu_time = 0, 220 .can_generate_method_entry_events = 0, 221 .can_generate_method_exit_events = 0, 222 .can_generate_all_class_hook_events = 0, 223 .can_generate_compiled_method_load_events = 0, 224 .can_generate_monitor_events = 0, 225 .can_generate_vm_object_alloc_events = 1, 226 .can_generate_native_method_bind_events = 1, 227 .can_generate_garbage_collection_events = 1, 228 .can_generate_object_free_events = 1, 229 .can_force_early_return = 0, 230 .can_get_owned_monitor_stack_depth_info = 0, 231 .can_get_constant_pool = 0, 232 .can_set_native_method_prefix = 0, 233 .can_retransform_classes = 1, 234 .can_retransform_any_class = 0, 235 .can_generate_resource_exhaustion_heap_events = 0, 236 .can_generate_resource_exhaustion_threads_events = 0, 237 }; 238 239 } // namespace openjdkjvmti 240 241 #endif // ART_RUNTIME_OPENJDKJVMTI_ART_JVMTI_H_ 242
