1 /* Copyright (C) 2017 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 #include "ti_threadgroup.h"
33
34 #include "art_field-inl.h"
35 #include "art_jvmti.h"
36 #include "base/logging.h"
37 #include "base/macros.h"
38 #include "base/mutex.h"
39 #include "handle_scope-inl.h"
40 #include "jni/jni_internal.h"
41 #include "mirror/class.h"
42 #include "mirror/object-inl.h"
43 #include "mirror/string.h"
44 #include "obj_ptr.h"
45 #include "object_lock.h"
46 #include "runtime.h"
47 #include "scoped_thread_state_change-inl.h"
48 #include "thread-current-inl.h"
49 #include "thread_list.h"
50 #include "well_known_classes-inl.h"
51
52 namespace openjdkjvmti {
53
54
GetTopThreadGroups(jvmtiEnv * env,jint * group_count_ptr,jthreadGroup ** groups_ptr)55 jvmtiError ThreadGroupUtil::GetTopThreadGroups(jvmtiEnv* env,
56 jint* group_count_ptr,
57 jthreadGroup** groups_ptr) {
58 // We only have a single top group. So we can take the current thread and move upwards.
59 if (group_count_ptr == nullptr || groups_ptr == nullptr) {
60 return ERR(NULL_POINTER);
61 }
62
63 art::Runtime* runtime = art::Runtime::Current();
64 if (runtime == nullptr) {
65 // Must be starting the runtime, or dying.
66 return ERR(WRONG_PHASE);
67 }
68
69 jobject sys_thread_group = runtime->GetSystemThreadGroup();
70 if (sys_thread_group == nullptr) {
71 // Seems we're still starting up.
72 return ERR(WRONG_PHASE);
73 }
74
75 unsigned char* data;
76 jvmtiError result = env->Allocate(sizeof(jthreadGroup), &data);
77 if (result != ERR(NONE)) {
78 return result;
79 }
80
81 jthreadGroup* groups = reinterpret_cast<jthreadGroup*>(data);
82 *groups =
83 reinterpret_cast<JNIEnv*>(art::Thread::Current()->GetJniEnv())->NewLocalRef(sys_thread_group);
84 *groups_ptr = groups;
85 *group_count_ptr = 1;
86
87 return ERR(NONE);
88 }
89
GetThreadGroupInfo(jvmtiEnv * env,jthreadGroup group,jvmtiThreadGroupInfo * info_ptr)90 jvmtiError ThreadGroupUtil::GetThreadGroupInfo(jvmtiEnv* env,
91 jthreadGroup group,
92 jvmtiThreadGroupInfo* info_ptr) {
93 if (group == nullptr) {
94 return ERR(INVALID_THREAD_GROUP);
95 }
96
97 art::ScopedObjectAccess soa(art::Thread::Current());
98 art::StackHandleScope<2> hs(soa.Self());
99 art::Handle<art::mirror::Class> tg_class =
100 hs.NewHandle(art::WellKnownClasses::java_lang_ThreadGroup.Get());
101 art::Handle<art::mirror::Object> thread_group =
102 hs.NewHandle(soa.Decode<art::mirror::Object>(group));
103 if (!thread_group->InstanceOf(tg_class.Get())) {
104 return ERR(INVALID_THREAD_GROUP);
105 }
106
107 // Do the name first. It's the only thing that can fail.
108 {
109 art::ArtField* name_field = art::WellKnownClasses::java_lang_ThreadGroup_name;
110 CHECK(name_field != nullptr);
111 art::ObjPtr<art::mirror::String> name_obj =
112 art::ObjPtr<art::mirror::String>::DownCast(name_field->GetObject(thread_group.Get()));
113 std::string tmp_str;
114 const char* tmp_cstr;
115 if (name_obj == nullptr) {
116 tmp_cstr = "";
117 } else {
118 tmp_str = name_obj->ToModifiedUtf8();
119 tmp_cstr = tmp_str.c_str();
120 }
121 jvmtiError result;
122 JvmtiUniquePtr<char[]> copy = CopyString(env, tmp_cstr, &result);
123 if (copy == nullptr) {
124 return result;
125 }
126 info_ptr->name = copy.release();
127 }
128
129 // Parent.
130 {
131 art::ArtField* parent_field = art::WellKnownClasses::java_lang_ThreadGroup_parent;
132 CHECK(parent_field != nullptr);
133 art::ObjPtr<art::mirror::Object> parent_group = parent_field->GetObject(thread_group.Get());
134 info_ptr->parent = parent_group == nullptr
135 ? nullptr
136 : soa.AddLocalReference<jthreadGroup>(parent_group);
137 }
138
139 // Max priority.
140 {
141 art::ArtField* prio_field = tg_class->FindDeclaredInstanceField("maxPriority", "I");
142 CHECK(prio_field != nullptr);
143 info_ptr->max_priority = static_cast<jint>(prio_field->GetInt(thread_group.Get()));
144 }
145
146 // Daemon.
147 {
148 art::ArtField* daemon_field = tg_class->FindDeclaredInstanceField("daemon", "Z");
149 CHECK(daemon_field != nullptr);
150 info_ptr->is_daemon = daemon_field->GetBoolean(thread_group.Get()) == 0 ? JNI_FALSE : JNI_TRUE;
151 }
152
153 return ERR(NONE);
154 }
155
156
IsInDesiredThreadGroup(art::Handle<art::mirror::Object> desired_thread_group,art::ObjPtr<art::mirror::Object> peer)157 static bool IsInDesiredThreadGroup(art::Handle<art::mirror::Object> desired_thread_group,
158 art::ObjPtr<art::mirror::Object> peer)
159 REQUIRES_SHARED(art::Locks::mutator_lock_) {
160 CHECK(desired_thread_group != nullptr);
161
162 art::ArtField* thread_group_field = art::WellKnownClasses::java_lang_Thread_group;
163 DCHECK(thread_group_field != nullptr);
164 art::ObjPtr<art::mirror::Object> group = thread_group_field->GetObject(peer);
165 return (group == desired_thread_group.Get());
166 }
167
GetThreads(art::Handle<art::mirror::Object> thread_group,std::vector<art::ObjPtr<art::mirror::Object>> * thread_peers)168 static void GetThreads(art::Handle<art::mirror::Object> thread_group,
169 std::vector<art::ObjPtr<art::mirror::Object>>* thread_peers)
170 REQUIRES_SHARED(art::Locks::mutator_lock_) REQUIRES(!art::Locks::thread_list_lock_) {
171 CHECK(thread_group != nullptr);
172
173 art::MutexLock mu(art::Thread::Current(), *art::Locks::thread_list_lock_);
174 for (art::Thread* t : art::Runtime::Current()->GetThreadList()->GetList()) {
175 if (t->IsStillStarting()) {
176 continue;
177 }
178 art::ObjPtr<art::mirror::Object> peer = t->GetPeerFromOtherThread();
179 if (peer == nullptr) {
180 continue;
181 }
182 if (IsInDesiredThreadGroup(thread_group, peer)) {
183 thread_peers->push_back(peer);
184 }
185 }
186 }
187
GetChildThreadGroups(art::Handle<art::mirror::Object> thread_group,std::vector<art::ObjPtr<art::mirror::Object>> * thread_groups)188 static void GetChildThreadGroups(art::Handle<art::mirror::Object> thread_group,
189 std::vector<art::ObjPtr<art::mirror::Object>>* thread_groups)
190 REQUIRES_SHARED(art::Locks::mutator_lock_) {
191 CHECK(thread_group != nullptr);
192
193 // Get the ThreadGroup[] "groups" out of this thread group...
194 art::ArtField* groups_field = art::WellKnownClasses::java_lang_ThreadGroup_groups;
195 art::ObjPtr<art::mirror::Object> groups_array = groups_field->GetObject(thread_group.Get());
196
197 if (groups_array == nullptr) {
198 return;
199 }
200 CHECK(groups_array->IsObjectArray());
201
202 art::ObjPtr<art::mirror::ObjectArray<art::mirror::Object>> groups_array_as_array =
203 groups_array->AsObjectArray<art::mirror::Object>();
204
205 // Copy all non-null elements.
206 for (auto entry : groups_array_as_array->Iterate()) {
207 if (entry != nullptr) {
208 thread_groups->push_back(entry);
209 }
210 }
211 }
212
GetThreadGroupChildren(jvmtiEnv * env,jthreadGroup group,jint * thread_count_ptr,jthread ** threads_ptr,jint * group_count_ptr,jthreadGroup ** groups_ptr)213 jvmtiError ThreadGroupUtil::GetThreadGroupChildren(jvmtiEnv* env,
214 jthreadGroup group,
215 jint* thread_count_ptr,
216 jthread** threads_ptr,
217 jint* group_count_ptr,
218 jthreadGroup** groups_ptr) {
219 if (group == nullptr) {
220 return ERR(INVALID_THREAD_GROUP);
221 }
222
223 art::ScopedObjectAccess soa(art::Thread::Current());
224 art::StackHandleScope<1> hs(soa.Self());
225 art::Handle<art::mirror::Object> thread_group =
226 hs.NewHandle(soa.Decode<art::mirror::Object>(group));
227 if (!thread_group->InstanceOf(art::WellKnownClasses::java_lang_ThreadGroup.Get())) {
228 return ERR(INVALID_THREAD_GROUP);
229 }
230
231
232 art::ObjectLock<art::mirror::Object> thread_group_lock(soa.Self(), thread_group);
233
234 std::vector<art::ObjPtr<art::mirror::Object>> thread_peers;
235 GetThreads(thread_group, &thread_peers);
236
237 std::vector<art::ObjPtr<art::mirror::Object>> thread_groups;
238 GetChildThreadGroups(thread_group, &thread_groups);
239
240 JvmtiUniquePtr<jthread[]> peers_uptr;
241 if (!thread_peers.empty()) {
242 jvmtiError res;
243 peers_uptr = AllocJvmtiUniquePtr<jthread[]>(env, thread_peers.size(), &res);
244 if (peers_uptr == nullptr) {
245 return res;
246 }
247 }
248
249 JvmtiUniquePtr<jthreadGroup[]> group_uptr;
250 if (!thread_groups.empty()) {
251 jvmtiError res;
252 group_uptr = AllocJvmtiUniquePtr<jthreadGroup[]>(env, thread_groups.size(), &res);
253 if (group_uptr == nullptr) {
254 return res;
255 }
256 }
257
258 // Can't fail anymore from here on.
259
260 // Copy data into out buffers.
261 for (size_t i = 0; i != thread_peers.size(); ++i) {
262 peers_uptr[i] = soa.AddLocalReference<jthread>(thread_peers[i]);
263 }
264 for (size_t i = 0; i != thread_groups.size(); ++i) {
265 group_uptr[i] = soa.AddLocalReference<jthreadGroup>(thread_groups[i]);
266 }
267
268 *thread_count_ptr = static_cast<jint>(thread_peers.size());
269 *threads_ptr = peers_uptr.release();
270 *group_count_ptr = static_cast<jint>(thread_groups.size());
271 *groups_ptr = group_uptr.release();
272
273 return ERR(NONE);
274 }
275
276 } // namespace openjdkjvmti
277