• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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