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
49namespace openjdkjvmti {
50
51class ObjectTagTable;
52
53// A structure that is a jvmtiEnv with additional information for the runtime.
54struct 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
74static constexpr jvmtiError OK = JVMTI_ERROR_NONE;
75
76// Special error code for unimplemented functions in JVMTI
77static constexpr jvmtiError ERR(NOT_IMPLEMENTED) = JVMTI_ERROR_NOT_AVAILABLE;
78
79static 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
89template <typename T>
90class 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
109template <typename T>
110class 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
130template <typename T>
131using JvmtiUniquePtr = std::unique_ptr<T, JvmtiDeleter<T>>;
132
133template <typename T>
134ALWAYS_INLINE
135static inline JvmtiUniquePtr<T> MakeJvmtiUniquePtr(jvmtiEnv* env, T* mem) {
136  return JvmtiUniquePtr<T>(mem, JvmtiDeleter<T>(env));
137}
138
139template <typename T>
140ALWAYS_INLINE
141static inline JvmtiUniquePtr<T> MakeJvmtiUniquePtr(jvmtiEnv* env, unsigned char* mem) {
142  return JvmtiUniquePtr<T>(reinterpret_cast<T*>(mem), JvmtiDeleter<T>(env));
143}
144
145template <typename T>
146ALWAYS_INLINE
147static 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
156template <typename T>
157ALWAYS_INLINE
158static 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
170ALWAYS_INLINE
171static 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
185ALWAYS_INLINE
186static 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
195const 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