1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <inttypes.h>
18 #include <memory>
19 #include <stdio.h>
20
21 #include "android-base/logging.h"
22 #include "android-base/stringprintf.h"
23
24 #include "jni.h"
25 #include "jvmti.h"
26 #include "scoped_local_ref.h"
27
28 // Test infrastructure
29 #include "jni_binder.h"
30 #include "jni_helper.h"
31 #include "jvmti_helper.h"
32 #include "test_env.h"
33 #include "ti_macros.h"
34
35 namespace art {
36 namespace Test911GetStackTrace {
37
38 using android::base::StringPrintf;
39
FindLineNumber(jint line_number_count,jvmtiLineNumberEntry * line_number_table,jlocation location)40 static jint FindLineNumber(jint line_number_count,
41 jvmtiLineNumberEntry* line_number_table,
42 jlocation location) {
43 if (line_number_table == nullptr) {
44 return -2;
45 }
46
47 jint line_number = -1;
48 for (jint i = 0; i != line_number_count; ++i) {
49 if (line_number_table[i].start_location > location) {
50 return line_number;
51 }
52 line_number = line_number_table[i].line_number;
53 }
54 return line_number;
55 }
56
TranslateJvmtiFrameInfoArray(JNIEnv * env,jvmtiFrameInfo * frames,jint count)57 static jobjectArray TranslateJvmtiFrameInfoArray(JNIEnv* env,
58 jvmtiFrameInfo* frames,
59 jint count) {
60 auto callback = [&](jint method_index) -> jobjectArray {
61 char* name;
62 char* sig;
63 char* gen;
64 {
65 jvmtiError result2 = jvmti_env->GetMethodName(frames[method_index].method, &name, &sig, &gen);
66 if (JvmtiErrorToException(env, jvmti_env, result2)) {
67 return nullptr;
68 }
69 }
70
71 jint line_number_count;
72 jvmtiLineNumberEntry* line_number_table;
73 {
74 jvmtiError line_result = jvmti_env->GetLineNumberTable(frames[method_index].method,
75 &line_number_count,
76 &line_number_table);
77 if (line_result != JVMTI_ERROR_NONE) {
78 // Accept absent info and native method errors.
79 if (line_result != JVMTI_ERROR_ABSENT_INFORMATION &&
80 line_result != JVMTI_ERROR_NATIVE_METHOD) {
81 JvmtiErrorToException(env, jvmti_env, line_result);
82 return nullptr;
83 }
84 line_number_table = nullptr;
85 line_number_count = 0;
86 }
87 }
88
89 auto inner_callback = [&](jint component_index) -> jstring {
90 switch (component_index) {
91 case 0:
92 return (name == nullptr) ? nullptr : env->NewStringUTF(name);
93 case 1:
94 return (sig == nullptr) ? nullptr : env->NewStringUTF(sig);
95 case 2:
96 return env->NewStringUTF(StringPrintf("%" PRId64, frames[method_index].location).c_str());
97 case 3: {
98 jint line_number = FindLineNumber(line_number_count,
99 line_number_table,
100 frames[method_index].location);
101 return env->NewStringUTF(StringPrintf("%d", line_number).c_str());
102 }
103 }
104 LOG(FATAL) << "Unreachable";
105 UNREACHABLE();
106 };
107 jobjectArray inner_array = CreateObjectArray(env, 4, "java/lang/String", inner_callback);
108
109 if (name != nullptr) {
110 jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(name));
111 }
112 if (sig != nullptr) {
113 jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(sig));
114 }
115 if (gen != nullptr) {
116 jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(gen));
117 }
118 if (line_number_table != nullptr) {
119 jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(line_number_table));
120 }
121
122 return inner_array;
123 };
124 return CreateObjectArray(env, count, "[Ljava/lang/String;", callback);
125 }
126
Java_art_PrintThread_getStackTrace(JNIEnv * env,jclass klass ATTRIBUTE_UNUSED,jthread thread,jint start,jint max)127 extern "C" JNIEXPORT jobjectArray JNICALL Java_art_PrintThread_getStackTrace(
128 JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jthread thread, jint start, jint max) {
129 std::unique_ptr<jvmtiFrameInfo[]> frames(new jvmtiFrameInfo[max]);
130
131 jint count;
132 {
133 jvmtiError result = jvmti_env->GetStackTrace(thread, start, max, frames.get(), &count);
134 if (JvmtiErrorToException(env, jvmti_env, result)) {
135 return nullptr;
136 }
137 }
138
139 return TranslateJvmtiFrameInfoArray(env, frames.get(), count);
140 }
141
Java_art_AllTraces_getAllStackTraces(JNIEnv * env,jclass klass ATTRIBUTE_UNUSED,jint max)142 extern "C" JNIEXPORT jobjectArray JNICALL Java_art_AllTraces_getAllStackTraces(
143 JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jint max) {
144 jint thread_count;
145 jvmtiStackInfo* stack_infos;
146 {
147 jvmtiError result = jvmti_env->GetAllStackTraces(max, &stack_infos, &thread_count);
148 if (JvmtiErrorToException(env, jvmti_env, result)) {
149 return nullptr;
150 }
151 }
152
153 auto callback = [&](jint thread_index) -> jobject {
154 auto inner_callback = [&](jint index) -> jobject {
155 if (index == 0) {
156 return stack_infos[thread_index].thread;
157 } else {
158 return TranslateJvmtiFrameInfoArray(env,
159 stack_infos[thread_index].frame_buffer,
160 stack_infos[thread_index].frame_count);
161 }
162 };
163 return CreateObjectArray(env, 2, "java/lang/Object", inner_callback);
164 };
165 jobjectArray ret = CreateObjectArray(env, thread_count, "[Ljava/lang/Object;", callback);
166 jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(stack_infos));
167 return ret;
168 }
169
Java_art_ThreadListTraces_getThreadListStackTraces(JNIEnv * env,jclass klass ATTRIBUTE_UNUSED,jobjectArray jthreads,jint max)170 extern "C" JNIEXPORT jobjectArray JNICALL Java_art_ThreadListTraces_getThreadListStackTraces(
171 JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jobjectArray jthreads, jint max) {
172 jint thread_count = env->GetArrayLength(jthreads);
173 std::unique_ptr<jthread[]> threads(new jthread[thread_count]);
174 for (jint i = 0; i != thread_count; ++i) {
175 threads[i] = env->GetObjectArrayElement(jthreads, i);
176 }
177
178 jvmtiStackInfo* stack_infos;
179 {
180 jvmtiError result = jvmti_env->GetThreadListStackTraces(thread_count,
181 threads.get(),
182 max,
183 &stack_infos);
184 if (JvmtiErrorToException(env, jvmti_env, result)) {
185 return nullptr;
186 }
187 }
188
189 auto callback = [&](jint thread_index) -> jobject {
190 auto inner_callback = [&](jint index) -> jobject {
191 if (index == 0) {
192 return stack_infos[thread_index].thread;
193 } else {
194 return TranslateJvmtiFrameInfoArray(env,
195 stack_infos[thread_index].frame_buffer,
196 stack_infos[thread_index].frame_count);
197 }
198 };
199 return CreateObjectArray(env, 2, "java/lang/Object", inner_callback);
200 };
201 jobjectArray ret = CreateObjectArray(env, thread_count, "[Ljava/lang/Object;", callback);
202 jvmti_env->Deallocate(reinterpret_cast<unsigned char*>(stack_infos));
203 return ret;
204 }
205
Java_art_Frames_getFrameCount(JNIEnv * env,jclass klass ATTRIBUTE_UNUSED,jthread thread)206 extern "C" JNIEXPORT jint JNICALL Java_art_Frames_getFrameCount(
207 JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jthread thread) {
208 jint count;
209 jvmtiError result = jvmti_env->GetFrameCount(thread, &count);
210 if (JvmtiErrorToException(env, jvmti_env, result)) {
211 return -1;
212 }
213 return count;
214 }
215
Java_art_Frames_getFrameLocation(JNIEnv * env,jclass klass ATTRIBUTE_UNUSED,jthread thread,jint depth)216 extern "C" JNIEXPORT jobjectArray JNICALL Java_art_Frames_getFrameLocation(
217 JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jthread thread, jint depth) {
218 jmethodID method;
219 jlocation location;
220
221 jvmtiError result = jvmti_env->GetFrameLocation(thread, depth, &method, &location);
222 if (JvmtiErrorToException(env, jvmti_env, result)) {
223 return nullptr;
224 }
225
226 auto callback = [&](jint index) -> jobject {
227 switch (index) {
228 case 0:
229 {
230 jclass decl_class;
231 jvmtiError class_result = jvmti_env->GetMethodDeclaringClass(method, &decl_class);
232 if (JvmtiErrorToException(env, jvmti_env, class_result)) {
233 return nullptr;
234 }
235 jint modifiers;
236 jvmtiError mod_result = jvmti_env->GetMethodModifiers(method, &modifiers);
237 if (JvmtiErrorToException(env, jvmti_env, mod_result)) {
238 return nullptr;
239 }
240 constexpr jint kStatic = 0x8;
241 return env->ToReflectedMethod(decl_class,
242 method,
243 (modifiers & kStatic) != 0 ? JNI_TRUE : JNI_FALSE);
244 }
245 case 1:
246 return env->NewStringUTF(
247 android::base::StringPrintf("%x", static_cast<uint32_t>(location)).c_str());
248 }
249 LOG(FATAL) << "Unreachable";
250 UNREACHABLE();
251 };
252 jobjectArray ret = CreateObjectArray(env, 2, "java/lang/Object", callback);
253 return ret;
254 }
255
256 } // namespace Test911GetStackTrace
257 } // namespace art
258