1 /*
2 * Copyright (C) 2015 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 #if __linux__
18 #include <errno.h>
19 #include <signal.h>
20 #include <string.h>
21 #include <sys/ptrace.h>
22 #include <sys/wait.h>
23 #include <unistd.h>
24 #endif
25
26 #include "jni.h"
27
28 #include <android-base/file.h>
29 #include <android-base/logging.h>
30 #include <android-base/stringprintf.h>
31 #include <backtrace/Backtrace.h>
32
33 #include "base/file_utils.h"
34 #include "base/logging.h"
35 #include "base/macros.h"
36 #include "base/mutex.h"
37 #include "base/utils.h"
38 #include "gc/heap.h"
39 #include "gc/space/image_space.h"
40 #include "jit/debugger_interface.h"
41 #include "oat_file.h"
42 #include "runtime.h"
43
44 namespace art {
45
46 // For testing debuggerd. We do not have expected-death tests, so can't test this by default.
47 // Code for this is copied from SignalTest.
48 static constexpr bool kCauseSegfault = false;
49 char* go_away_compiler_cfi = nullptr;
50
CauseSegfault()51 static void CauseSegfault() {
52 #if defined(__arm__) || defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
53 // On supported architectures we cause a real SEGV.
54 *go_away_compiler_cfi = 'a';
55 #else
56 // On other architectures we simulate SEGV.
57 kill(getpid(), SIGSEGV);
58 #endif
59 }
60
Java_Main_startSecondaryProcess(JNIEnv *,jclass)61 extern "C" JNIEXPORT jint JNICALL Java_Main_startSecondaryProcess(JNIEnv*, jclass) {
62 printf("Java_Main_startSecondaryProcess\n");
63 #if __linux__
64 // Get our command line so that we can use it to start identical process.
65 std::string cmdline; // null-separated and null-terminated arguments.
66 android::base::ReadFileToString("/proc/self/cmdline", &cmdline);
67 cmdline = cmdline + "--secondary" + '\0'; // Let the child know it is a helper.
68
69 // Split the string into individual arguments suitable for execv.
70 std::vector<char*> argv;
71 for (size_t i = 0; i < cmdline.size(); i += strlen(&cmdline[i]) + 1) {
72 argv.push_back(&cmdline[i]);
73 }
74 argv.push_back(nullptr); // Terminate the list.
75
76 pid_t pid = fork();
77 if (pid < 0) {
78 LOG(FATAL) << "Fork failed";
79 } else if (pid == 0) {
80 execv(argv[0], argv.data());
81 exit(1);
82 }
83 return pid;
84 #else
85 return 0;
86 #endif
87 }
88
Java_Main_sigstop(JNIEnv *,jclass)89 extern "C" JNIEXPORT jboolean JNICALL Java_Main_sigstop(JNIEnv*, jclass) {
90 printf("Java_Main_sigstop\n");
91 #if __linux__
92 MutexLock mu(Thread::Current(), *GetNativeDebugInfoLock()); // Avoid races with the JIT thread.
93 raise(SIGSTOP);
94 #endif
95 return true; // Prevent the compiler from tail-call optimizing this method away.
96 }
97
98 // Helper to look for a sequence in the stack trace.
99 #if __linux__
CheckStack(Backtrace * bt,const std::vector<std::string> & seq)100 static bool CheckStack(Backtrace* bt, const std::vector<std::string>& seq) {
101 size_t cur_search_index = 0; // The currently active index in seq.
102 CHECK_GT(seq.size(), 0U);
103
104 for (Backtrace::const_iterator it = bt->begin(); it != bt->end(); ++it) {
105 if (BacktraceMap::IsValid(it->map)) {
106 LOG(INFO) << "Got " << it->func_name << ", looking for " << seq[cur_search_index];
107 if (it->func_name.find(seq[cur_search_index]) != std::string::npos) {
108 cur_search_index++;
109 if (cur_search_index == seq.size()) {
110 return true;
111 }
112 }
113 }
114 }
115
116 printf("Cannot find %s in backtrace:\n", seq[cur_search_index].c_str());
117 for (Backtrace::const_iterator it = bt->begin(); it != bt->end(); ++it) {
118 if (BacktraceMap::IsValid(it->map)) {
119 printf(" %s\n", Backtrace::FormatFrameData(&*it).c_str());
120 }
121 }
122
123 return false;
124 }
125
MoreErrorInfo(pid_t pid,bool sig_quit_on_fail)126 static void MoreErrorInfo(pid_t pid, bool sig_quit_on_fail) {
127 PrintFileToLog(android::base::StringPrintf("/proc/%d/maps", pid), ::android::base::ERROR);
128
129 if (sig_quit_on_fail) {
130 int res = kill(pid, SIGQUIT);
131 if (res != 0) {
132 PLOG(ERROR) << "Failed to send signal";
133 }
134 }
135 }
136 #endif
137
Java_Main_unwindInProcess(JNIEnv *,jclass)138 extern "C" JNIEXPORT jboolean JNICALL Java_Main_unwindInProcess(JNIEnv*, jclass) {
139 printf("Java_Main_unwindInProcess\n");
140 #if __linux__
141 MutexLock mu(Thread::Current(), *GetNativeDebugInfoLock()); // Avoid races with the JIT thread.
142
143 std::unique_ptr<Backtrace> bt(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, GetTid()));
144 if (!bt->Unwind(0, nullptr)) {
145 printf("Cannot unwind in process.\n");
146 return JNI_FALSE;
147 } else if (bt->NumFrames() == 0) {
148 printf("No frames for unwind in process.\n");
149 return JNI_FALSE;
150 }
151
152 // We cannot really parse an exact stack, as the optimizing compiler may inline some functions.
153 // This is also risky, as deduping might play a trick on us, so the test needs to make sure that
154 // only unique functions are being expected.
155 // "mini-debug-info" does not include parameters to save space.
156 std::vector<std::string> seq = {
157 "Java_Main_unwindInProcess", // This function.
158 "java.util.Arrays.binarySearch0", // Framework method.
159 "Base.$noinline$runTest", // Method in other dex file.
160 "Main.main" // The Java entry method.
161 };
162
163 bool result = CheckStack(bt.get(), seq);
164 if (!kCauseSegfault) {
165 return result ? JNI_TRUE : JNI_FALSE;
166 } else {
167 LOG(INFO) << "Result of check-stack: " << result;
168 }
169 #endif
170
171 if (kCauseSegfault) {
172 CauseSegfault();
173 }
174
175 return JNI_FALSE;
176 }
177
178 #if __linux__
179 static constexpr int kSleepTimeMicroseconds = 50000; // 0.05 seconds
180 static constexpr int kMaxTotalSleepTimeMicroseconds = 10000000; // 10 seconds
181
182 // Wait for a sigstop. This code is copied from libbacktrace.
wait_for_sigstop(pid_t tid,int * total_sleep_time_usec,bool * detach_failed ATTRIBUTE_UNUSED)183 int wait_for_sigstop(pid_t tid, int* total_sleep_time_usec, bool* detach_failed ATTRIBUTE_UNUSED) {
184 for (;;) {
185 int status;
186 pid_t n = TEMP_FAILURE_RETRY(waitpid(tid, &status, __WALL | WNOHANG));
187 if (n == -1) {
188 PLOG(WARNING) << "waitpid failed: tid " << tid;
189 break;
190 } else if (n == tid) {
191 if (WIFSTOPPED(status)) {
192 return WSTOPSIG(status);
193 } else {
194 PLOG(ERROR) << "unexpected waitpid response: n=" << n << ", status=" << std::hex << status;
195 break;
196 }
197 }
198
199 if (*total_sleep_time_usec > kMaxTotalSleepTimeMicroseconds) {
200 PLOG(WARNING) << "timed out waiting for stop signal: tid=" << tid;
201 break;
202 }
203
204 usleep(kSleepTimeMicroseconds);
205 *total_sleep_time_usec += kSleepTimeMicroseconds;
206 }
207
208 return -1;
209 }
210 #endif
211
Java_Main_unwindOtherProcess(JNIEnv *,jclass,jint pid_int)212 extern "C" JNIEXPORT jboolean JNICALL Java_Main_unwindOtherProcess(JNIEnv*, jclass, jint pid_int) {
213 printf("Java_Main_unwindOtherProcess\n");
214 #if __linux__
215 pid_t pid = static_cast<pid_t>(pid_int);
216
217 // SEIZE is like ATTACH, but it does not stop the process (we let it stop itself).
218 if (ptrace(PTRACE_SEIZE, pid, 0, 0)) {
219 // Were not able to attach, bad.
220 printf("Failed to attach to other process.\n");
221 PLOG(ERROR) << "Failed to attach.";
222 kill(pid, SIGKILL);
223 return JNI_FALSE;
224 }
225
226 bool detach_failed = false;
227 int total_sleep_time_usec = 0;
228 int signal = wait_for_sigstop(pid, &total_sleep_time_usec, &detach_failed);
229 if (signal != SIGSTOP) {
230 printf("wait_for_sigstop failed.\n");
231 return JNI_FALSE;
232 }
233
234 std::unique_ptr<Backtrace> bt(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD));
235 bool result = true;
236 if (!bt->Unwind(0, nullptr)) {
237 printf("Cannot unwind other process.\n");
238 result = false;
239 } else if (bt->NumFrames() == 0) {
240 printf("No frames for unwind of other process.\n");
241 result = false;
242 }
243
244 if (result) {
245 // See comment in unwindInProcess for non-exact stack matching.
246 // "mini-debug-info" does not include parameters to save space.
247 std::vector<std::string> seq = {
248 "Java_Main_sigstop", // The stop function in the other process.
249 "java.util.Arrays.binarySearch0", // Framework method.
250 "Base.$noinline$runTest", // Method in other dex file.
251 "Main.main" // The Java entry method.
252 };
253
254 result = CheckStack(bt.get(), seq);
255 }
256
257 constexpr bool kSigQuitOnFail = true;
258 if (!result) {
259 printf("Failed to unwind secondary with pid %d\n", pid);
260 MoreErrorInfo(pid, kSigQuitOnFail);
261 }
262
263 if (ptrace(PTRACE_DETACH, pid, 0, 0) != 0) {
264 printf("Detach failed\n");
265 PLOG(ERROR) << "Detach failed";
266 }
267
268 // If we failed to unwind and induced an ANR dump, give the child some time (20s).
269 if (!result && kSigQuitOnFail) {
270 sleep(20);
271 }
272
273 // Kill the other process once we are done with it.
274 kill(pid, SIGKILL);
275
276 return result ? JNI_TRUE : JNI_FALSE;
277 #else
278 printf("Remote unwind supported only on linux\n");
279 UNUSED(pid_int);
280 return JNI_FALSE;
281 #endif
282 }
283
284 } // namespace art
285