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
AsArtJvmTiEnvArtJvmTiEnv111 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
GetJniEnv(jvmtiEnv * env)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:
JvmtiDeleter()140 JvmtiDeleter() : env_(nullptr) {}
JvmtiDeleter(jvmtiEnv * env)141 explicit JvmtiDeleter(jvmtiEnv* env) : env_(env) {}
142
143 JvmtiDeleter(JvmtiDeleter&) = default;
144 JvmtiDeleter(JvmtiDeleter&&) = default;
145 JvmtiDeleter& operator=(const JvmtiDeleter&) = default;
146
operator()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:
JvmtiDeleter()160 JvmtiDeleter() : env_(nullptr) {}
JvmtiDeleter(jvmtiEnv * env)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>
operator()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
MakeJvmtiUniquePtr(jvmtiEnv * env,T * mem)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
MakeJvmtiUniquePtr(jvmtiEnv * env,unsigned char * mem)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
AllocJvmtiUniquePtr(jvmtiEnv * env,jvmtiError * error)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
AllocJvmtiUniquePtr(jvmtiEnv * env,size_t count,jvmtiError * error)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
CopyDataIntoJvmtiBuffer(ArtJvmTiEnv * env,const unsigned char * source,jint len,unsigned char ** dest)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
CopyString(jvmtiEnv * env,const char * src,jvmtiError * error)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