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 <unistd.h> 22 #include <sys/ptrace.h> 23 #include <sys/wait.h> 24 #endif 25 26 #include "jni.h" 27 28 #include <backtrace/Backtrace.h> 29 30 #include "base/logging.h" 31 #include "base/macros.h" 32 #include "gc/heap.h" 33 #include "gc/space/image_space.h" 34 #include "oat_file.h" 35 #include "utils.h" 36 37 namespace art { 38 39 // For testing debuggerd. We do not have expected-death tests, so can't test this by default. 40 // Code for this is copied from SignalTest. 41 static constexpr bool kCauseSegfault = false; 42 char* go_away_compiler_cfi = nullptr; 43 44 static void CauseSegfault() { 45 #if defined(__arm__) || defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) 46 // On supported architectures we cause a real SEGV. 47 *go_away_compiler_cfi = 'a'; 48 #else 49 // On other architectures we simulate SEGV. 50 kill(getpid(), SIGSEGV); 51 #endif 52 } 53 54 extern "C" JNIEXPORT jboolean JNICALL Java_Main_sleep(JNIEnv*, jobject, jint, jboolean, jdouble) { 55 // Keep pausing. 56 printf("Going to sleep\n"); 57 for (;;) { 58 pause(); 59 } 60 } 61 62 // Helper to look for a sequence in the stack trace. 63 #if __linux__ 64 static bool CheckStack(Backtrace* bt, const std::vector<std::string>& seq) { 65 size_t cur_search_index = 0; // The currently active index in seq. 66 CHECK_GT(seq.size(), 0U); 67 68 for (Backtrace::const_iterator it = bt->begin(); it != bt->end(); ++it) { 69 if (BacktraceMap::IsValid(it->map)) { 70 LOG(INFO) << "Got " << it->func_name << ", looking for " << seq[cur_search_index]; 71 if (it->func_name == seq[cur_search_index]) { 72 cur_search_index++; 73 if (cur_search_index == seq.size()) { 74 return true; 75 } 76 } 77 } 78 } 79 80 printf("Cannot find %s in backtrace:\n", seq[cur_search_index].c_str()); 81 for (Backtrace::const_iterator it = bt->begin(); it != bt->end(); ++it) { 82 if (BacktraceMap::IsValid(it->map)) { 83 printf(" %s\n", it->func_name.c_str()); 84 } 85 } 86 87 return false; 88 } 89 #endif 90 91 // Currently we have to fall back to our own loader for the boot image when it's compiled PIC 92 // because its base is zero. Thus in-process unwinding through it won't work. This is a helper 93 // detecting this. 94 #if __linux__ 95 static bool IsPicImage() { 96 std::vector<gc::space::ImageSpace*> image_spaces = 97 Runtime::Current()->GetHeap()->GetBootImageSpaces(); 98 CHECK(!image_spaces.empty()); // We should be running with an image. 99 const OatFile* oat_file = image_spaces[0]->GetOatFile(); 100 CHECK(oat_file != nullptr); // We should have an oat file to go with the image. 101 return oat_file->IsPic(); 102 } 103 #endif 104 105 extern "C" JNIEXPORT jboolean JNICALL Java_Main_unwindInProcess( 106 JNIEnv*, 107 jobject, 108 jboolean full_signatrues, 109 jint, 110 jboolean) { 111 #if __linux__ 112 if (IsPicImage()) { 113 LOG(INFO) << "Image is pic, in-process unwinding check bypassed."; 114 return JNI_TRUE; 115 } 116 117 // TODO: What to do on Valgrind? 118 119 std::unique_ptr<Backtrace> bt(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, GetTid())); 120 if (!bt->Unwind(0, nullptr)) { 121 printf("Cannot unwind in process.\n"); 122 return JNI_FALSE; 123 } else if (bt->NumFrames() == 0) { 124 printf("No frames for unwind in process.\n"); 125 return JNI_FALSE; 126 } 127 128 // We cannot really parse an exact stack, as the optimizing compiler may inline some functions. 129 // This is also risky, as deduping might play a trick on us, so the test needs to make sure that 130 // only unique functions are being expected. 131 // "mini-debug-info" does not include parameters to save space. 132 std::vector<std::string> seq = { 133 "Java_Main_unwindInProcess", // This function. 134 "Main.unwindInProcess", // The corresponding Java native method frame. 135 "int java.util.Arrays.binarySearch(java.lang.Object[], int, int, java.lang.Object, java.util.Comparator)", // Framework method. 136 "Main.main" // The Java entry method. 137 }; 138 std::vector<std::string> full_seq = { 139 "Java_Main_unwindInProcess", // This function. 140 "boolean Main.unwindInProcess(boolean, int, boolean)", // The corresponding Java native method frame. 141 "int java.util.Arrays.binarySearch(java.lang.Object[], int, int, java.lang.Object, java.util.Comparator)", // Framework method. 142 "void Main.main(java.lang.String[])" // The Java entry method. 143 }; 144 145 bool result = CheckStack(bt.get(), full_signatrues ? full_seq : seq); 146 if (!kCauseSegfault) { 147 return result ? JNI_TRUE : JNI_FALSE; 148 } else { 149 LOG(INFO) << "Result of check-stack: " << result; 150 } 151 #endif 152 153 if (kCauseSegfault) { 154 CauseSegfault(); 155 } 156 157 return JNI_FALSE; 158 } 159 160 #if __linux__ 161 static constexpr int kSleepTimeMicroseconds = 50000; // 0.05 seconds 162 static constexpr int kMaxTotalSleepTimeMicroseconds = 1000000; // 1 second 163 164 // Wait for a sigstop. This code is copied from libbacktrace. 165 int wait_for_sigstop(pid_t tid, int* total_sleep_time_usec, bool* detach_failed ATTRIBUTE_UNUSED) { 166 for (;;) { 167 int status; 168 pid_t n = TEMP_FAILURE_RETRY(waitpid(tid, &status, __WALL | WNOHANG)); 169 if (n == -1) { 170 PLOG(WARNING) << "waitpid failed: tid " << tid; 171 break; 172 } else if (n == tid) { 173 if (WIFSTOPPED(status)) { 174 return WSTOPSIG(status); 175 } else { 176 PLOG(ERROR) << "unexpected waitpid response: n=" << n << ", status=" << std::hex << status; 177 break; 178 } 179 } 180 181 if (*total_sleep_time_usec > kMaxTotalSleepTimeMicroseconds) { 182 PLOG(WARNING) << "timed out waiting for stop signal: tid=" << tid; 183 break; 184 } 185 186 usleep(kSleepTimeMicroseconds); 187 *total_sleep_time_usec += kSleepTimeMicroseconds; 188 } 189 190 return -1; 191 } 192 #endif 193 194 extern "C" JNIEXPORT jboolean JNICALL Java_Main_unwindOtherProcess( 195 JNIEnv*, 196 jobject, 197 jboolean full_signatrues, 198 jint pid_int) { 199 #if __linux__ 200 // TODO: What to do on Valgrind? 201 pid_t pid = static_cast<pid_t>(pid_int); 202 203 // OK, this is painful. debuggerd uses ptrace to unwind other processes. 204 205 if (ptrace(PTRACE_ATTACH, pid, 0, 0)) { 206 // Were not able to attach, bad. 207 printf("Failed to attach to other process.\n"); 208 PLOG(ERROR) << "Failed to attach."; 209 kill(pid, SIGKILL); 210 return JNI_FALSE; 211 } 212 213 kill(pid, SIGSTOP); 214 215 bool detach_failed = false; 216 int total_sleep_time_usec = 0; 217 int signal = wait_for_sigstop(pid, &total_sleep_time_usec, &detach_failed); 218 if (signal == -1) { 219 LOG(WARNING) << "wait_for_sigstop failed."; 220 } 221 222 std::unique_ptr<Backtrace> bt(Backtrace::Create(pid, BACKTRACE_CURRENT_THREAD)); 223 bool result = true; 224 if (!bt->Unwind(0, nullptr)) { 225 printf("Cannot unwind other process.\n"); 226 result = false; 227 } else if (bt->NumFrames() == 0) { 228 printf("No frames for unwind of other process.\n"); 229 result = false; 230 } 231 232 if (result) { 233 // See comment in unwindInProcess for non-exact stack matching. 234 // "mini-debug-info" does not include parameters to save space. 235 std::vector<std::string> seq = { 236 // "Java_Main_sleep", // The sleep function being executed in the 237 // other runtime. 238 // Note: For some reason, the name isn't 239 // resolved, so don't look for it right now. 240 "Main.sleep", // The corresponding Java native method frame. 241 "int java.util.Arrays.binarySearch(java.lang.Object[], int, int, java.lang.Object, java.util.Comparator)", // Framework method. 242 "Main.main" // The Java entry method. 243 }; 244 std::vector<std::string> full_seq = { 245 // "Java_Main_sleep", // The sleep function being executed in the 246 // other runtime. 247 // Note: For some reason, the name isn't 248 // resolved, so don't look for it right now. 249 "boolean Main.sleep(int, boolean, double)", // The corresponding Java native method frame. 250 "int java.util.Arrays.binarySearch(java.lang.Object[], int, int, java.lang.Object, java.util.Comparator)", // Framework method. 251 "void Main.main(java.lang.String[])" // The Java entry method. 252 }; 253 254 result = CheckStack(bt.get(), full_signatrues ? full_seq : seq); 255 } 256 257 if (ptrace(PTRACE_DETACH, pid, 0, 0) != 0) { 258 PLOG(ERROR) << "Detach failed"; 259 } 260 261 // Kill the other process once we are done with it. 262 kill(pid, SIGKILL); 263 264 return result ? JNI_TRUE : JNI_FALSE; 265 #else 266 UNUSED(pid_int); 267 return JNI_FALSE; 268 #endif 269 } 270 271 } // namespace art 272
