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
AsArtJvmTiEnvArtJvmTiEnv67 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
GetJniEnv(jvmtiEnv * env)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:
JvmtiDeleter()92 JvmtiDeleter() : env_(nullptr) {}
JvmtiDeleter(jvmtiEnv * env)93 explicit JvmtiDeleter(jvmtiEnv* env) : env_(env) {}
94
95 JvmtiDeleter(JvmtiDeleter&) = default;
96 JvmtiDeleter(JvmtiDeleter&&) = default;
97 JvmtiDeleter& operator=(const JvmtiDeleter&) = default;
98
operator()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:
JvmtiDeleter()112 JvmtiDeleter() : env_(nullptr) {}
JvmtiDeleter(jvmtiEnv * env)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>
operator()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
MakeJvmtiUniquePtr(jvmtiEnv * env,T * mem)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
MakeJvmtiUniquePtr(jvmtiEnv * env,unsigned char * mem)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
AllocJvmtiUniquePtr(jvmtiEnv * env,jvmtiError * error)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
AllocJvmtiUniquePtr(jvmtiEnv * env,size_t count,jvmtiError * error)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
CopyDataIntoJvmtiBuffer(ArtJvmTiEnv * env,const unsigned char * source,jint len,unsigned char ** dest)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
CopyString(jvmtiEnv * env,const char * src,jvmtiError * error)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