1 /*
2 * Copyright (C) 2016 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 "native_stack_dump.h"
18
19 #include <memory>
20 #include <ostream>
21
22 #include <stdio.h>
23
24 #include "art_method.h"
25
26 // For DumpNativeStack.
27 #include <backtrace/Backtrace.h>
28 #include <backtrace/BacktraceMap.h>
29
30 #if defined(__linux__)
31
32 #include <memory>
33 #include <vector>
34
35 #include <linux/unistd.h>
36 #include <poll.h>
37 #include <signal.h>
38 #include <stdlib.h>
39 #include <sys/time.h>
40 #include <sys/types.h>
41
42 #include "android-base/file.h"
43 #include "android-base/stringprintf.h"
44 #include "android-base/strings.h"
45
46 #include "arch/instruction_set.h"
47 #include "base/aborting.h"
48 #include "base/bit_utils.h"
49 #include "base/file_utils.h"
50 #include "base/memory_tool.h"
51 #include "base/mutex.h"
52 #include "base/os.h"
53 #include "base/unix_file/fd_file.h"
54 #include "base/utils.h"
55 #include "class_linker.h"
56 #include "entrypoints/runtime_asm_entrypoints.h"
57 #include "oat_quick_method_header.h"
58 #include "runtime.h"
59 #include "thread-current-inl.h"
60
61 #endif
62
63 namespace art {
64
65 #if defined(__linux__)
66
67 using android::base::StringPrintf;
68
69 static constexpr bool kUseAddr2line = !kIsTargetBuild;
70
FindAddr2line()71 std::string FindAddr2line() {
72 #ifdef ART_CLANG_PATH
73 const char* env_value = getenv("ANDROID_BUILD_TOP");
74 if (env_value != nullptr) {
75 return std::string(env_value) + "/" + ART_CLANG_PATH + "/bin/llvm-addr2line";
76 }
77 #endif
78 return std::string("/usr/bin/addr2line");
79 }
80
81 ALWAYS_INLINE
WritePrefix(std::ostream & os,const char * prefix,bool odd)82 static inline void WritePrefix(std::ostream& os, const char* prefix, bool odd) {
83 if (prefix != nullptr) {
84 os << prefix;
85 }
86 os << " ";
87 if (!odd) {
88 os << " ";
89 }
90 }
91
92 // The state of an open pipe to addr2line. In "server" mode, addr2line takes input on stdin
93 // and prints the result to stdout. This struct keeps the state of the open connection.
94 struct Addr2linePipe {
Addr2linePipeart::Addr2linePipe95 Addr2linePipe(int in_fd, int out_fd, const std::string& file_name, pid_t pid)
96 : in(in_fd, false), out(out_fd, false), file(file_name), child_pid(pid), odd(true) {}
97
~Addr2linePipeart::Addr2linePipe98 ~Addr2linePipe() {
99 kill(child_pid, SIGKILL);
100 }
101
102 File in; // The file descriptor that is connected to the output of addr2line.
103 File out; // The file descriptor that is connected to the input of addr2line.
104
105 const std::string file; // The file addr2line is working on, so that we know when to close
106 // and restart.
107 const pid_t child_pid; // The pid of the child, which we should kill when we're done.
108 bool odd; // Print state for indentation of lines.
109 };
110
Connect(const std::string & name,const char * args[])111 static std::unique_ptr<Addr2linePipe> Connect(const std::string& name, const char* args[]) {
112 int caller_to_addr2line[2];
113 int addr2line_to_caller[2];
114
115 if (pipe(caller_to_addr2line) == -1) {
116 return nullptr;
117 }
118 if (pipe(addr2line_to_caller) == -1) {
119 close(caller_to_addr2line[0]);
120 close(caller_to_addr2line[1]);
121 return nullptr;
122 }
123
124 pid_t pid = fork();
125 if (pid == -1) {
126 close(caller_to_addr2line[0]);
127 close(caller_to_addr2line[1]);
128 close(addr2line_to_caller[0]);
129 close(addr2line_to_caller[1]);
130 return nullptr;
131 }
132
133 if (pid == 0) {
134 dup2(caller_to_addr2line[0], STDIN_FILENO);
135 dup2(addr2line_to_caller[1], STDOUT_FILENO);
136
137 close(caller_to_addr2line[0]);
138 close(caller_to_addr2line[1]);
139 close(addr2line_to_caller[0]);
140 close(addr2line_to_caller[1]);
141
142 execv(args[0], const_cast<char* const*>(args));
143 exit(1);
144 } else {
145 close(caller_to_addr2line[0]);
146 close(addr2line_to_caller[1]);
147 return std::make_unique<Addr2linePipe>(addr2line_to_caller[0],
148 caller_to_addr2line[1],
149 name,
150 pid);
151 }
152 }
153
Drain(size_t expected,const char * prefix,std::unique_ptr<Addr2linePipe> * pipe,std::ostream & os)154 static void Drain(size_t expected,
155 const char* prefix,
156 std::unique_ptr<Addr2linePipe>* pipe /* inout */,
157 std::ostream& os) {
158 DCHECK(pipe != nullptr);
159 DCHECK(pipe->get() != nullptr);
160 int in = pipe->get()->in.Fd();
161 DCHECK_GE(in, 0);
162
163 bool prefix_written = false;
164
165 for (;;) {
166 constexpr uint32_t kWaitTimeExpectedMilli = 500;
167 constexpr uint32_t kWaitTimeUnexpectedMilli = 50;
168
169 int timeout = expected > 0 ? kWaitTimeExpectedMilli : kWaitTimeUnexpectedMilli;
170 struct pollfd read_fd{in, POLLIN, 0};
171 int retval = TEMP_FAILURE_RETRY(poll(&read_fd, 1, timeout));
172 if (retval == -1) {
173 // An error occurred.
174 pipe->reset();
175 return;
176 }
177
178 if (retval == 0) {
179 // Timeout.
180 return;
181 }
182
183 if (!(read_fd.revents & POLLIN)) {
184 // addr2line call exited.
185 pipe->reset();
186 return;
187 }
188
189 constexpr size_t kMaxBuffer = 128; // Relatively small buffer. Should be OK as we're on an
190 // alt stack, but just to be sure...
191 char buffer[kMaxBuffer];
192 memset(buffer, 0, kMaxBuffer);
193 int bytes_read = TEMP_FAILURE_RETRY(read(in, buffer, kMaxBuffer - 1));
194 if (bytes_read <= 0) {
195 // This should not really happen...
196 pipe->reset();
197 return;
198 }
199 buffer[bytes_read] = '\0';
200
201 char* tmp = buffer;
202 while (*tmp != 0) {
203 if (!prefix_written) {
204 WritePrefix(os, prefix, (*pipe)->odd);
205 prefix_written = true;
206 }
207 char* new_line = strchr(tmp, '\n');
208 if (new_line == nullptr) {
209 os << tmp;
210
211 break;
212 } else {
213 char saved = *(new_line + 1);
214 *(new_line + 1) = 0;
215 os << tmp;
216 *(new_line + 1) = saved;
217
218 tmp = new_line + 1;
219 prefix_written = false;
220 (*pipe)->odd = !(*pipe)->odd;
221
222 if (expected > 0) {
223 expected--;
224 }
225 }
226 }
227 }
228 }
229
Addr2line(const std::string & map_src,uintptr_t offset,std::ostream & os,const char * prefix,std::unique_ptr<Addr2linePipe> * pipe)230 static void Addr2line(const std::string& map_src,
231 uintptr_t offset,
232 std::ostream& os,
233 const char* prefix,
234 std::unique_ptr<Addr2linePipe>* pipe /* inout */) {
235 std::array<const char*, 3> kIgnoreSuffixes{ ".dex", ".jar", ".vdex" };
236 for (const char* ignore_suffix : kIgnoreSuffixes) {
237 if (android::base::EndsWith(map_src, ignore_suffix)) {
238 // Ignore file names that do not have map information addr2line can consume. e.g. vdex
239 // files are special frames injected for the interpreter so they don't have any line
240 // number information available.
241 return;
242 }
243 }
244 if (map_src == "[vdso]") {
245 // addr2line will not work on the vdso.
246 return;
247 }
248
249 if (*pipe == nullptr || (*pipe)->file != map_src) {
250 if (*pipe != nullptr) {
251 Drain(0, prefix, pipe, os);
252 }
253 pipe->reset(); // Close early.
254
255 std::string addr2linePath = FindAddr2line();
256 const char* args[7] = {
257 addr2linePath.c_str(),
258 "--functions",
259 "--inlines",
260 "--demangle",
261 "-e",
262 map_src.c_str(),
263 nullptr
264 };
265 *pipe = Connect(map_src, args);
266 }
267
268 Addr2linePipe* pipe_ptr = pipe->get();
269 if (pipe_ptr == nullptr) {
270 // Failed...
271 return;
272 }
273
274 // Send the offset.
275 const std::string hex_offset = StringPrintf("0x%zx\n", offset);
276
277 if (!pipe_ptr->out.WriteFully(hex_offset.data(), hex_offset.length())) {
278 // Error. :-(
279 pipe->reset();
280 return;
281 }
282
283 // Now drain (expecting two lines).
284 Drain(2U, prefix, pipe, os);
285 }
286
RunCommand(const std::string & cmd)287 static bool RunCommand(const std::string& cmd) {
288 FILE* stream = popen(cmd.c_str(), "r");
289 if (stream) {
290 pclose(stream);
291 return true;
292 } else {
293 return false;
294 }
295 }
296
PcIsWithinQuickCode(ArtMethod * method,uintptr_t pc)297 static bool PcIsWithinQuickCode(ArtMethod* method, uintptr_t pc) NO_THREAD_SAFETY_ANALYSIS {
298 const void* entry_point = method->GetEntryPointFromQuickCompiledCode();
299 if (entry_point == nullptr) {
300 return pc == 0;
301 }
302 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
303 if (class_linker->IsQuickGenericJniStub(entry_point) ||
304 class_linker->IsQuickResolutionStub(entry_point) ||
305 class_linker->IsQuickToInterpreterBridge(entry_point)) {
306 return false;
307 }
308 // The backtrace library might have heuristically subracted instruction
309 // size from the pc, to pretend the pc is at the calling instruction.
310 if (reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()) - pc <= 4) {
311 return false;
312 }
313 uintptr_t code = reinterpret_cast<uintptr_t>(EntryPointToCodePointer(entry_point));
314 uintptr_t code_size = reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].GetCodeSize();
315 return code <= pc && pc <= (code + code_size);
316 }
317
DumpNativeStack(std::ostream & os,pid_t tid,BacktraceMap * existing_map,const char * prefix,ArtMethod * current_method,void * ucontext_ptr,bool skip_frames)318 void DumpNativeStack(std::ostream& os,
319 pid_t tid,
320 BacktraceMap* existing_map,
321 const char* prefix,
322 ArtMethod* current_method,
323 void* ucontext_ptr,
324 bool skip_frames) {
325 // Historical note: This was disabled when running under Valgrind (b/18119146).
326
327 BacktraceMap* map = existing_map;
328 std::unique_ptr<BacktraceMap> tmp_map;
329 if (map == nullptr) {
330 tmp_map.reset(BacktraceMap::Create(getpid()));
331 map = tmp_map.get();
332 }
333 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, tid, map));
334 backtrace->SetSkipFrames(skip_frames);
335 if (!backtrace->Unwind(0, reinterpret_cast<ucontext*>(ucontext_ptr))) {
336 os << prefix << "(backtrace::Unwind failed for thread " << tid
337 << ": " << backtrace->GetErrorString(backtrace->GetError()) << ")" << std::endl;
338 return;
339 } else if (backtrace->NumFrames() == 0) {
340 os << prefix << "(no native stack frames for thread " << tid << ")" << std::endl;
341 return;
342 }
343
344 // Check whether we have and should use addr2line.
345 bool use_addr2line;
346 if (kUseAddr2line) {
347 // Try to run it to see whether we have it. Push an argument so that it doesn't assume a.out
348 // and print to stderr.
349 use_addr2line = (gAborting > 0) && RunCommand(FindAddr2line() + " -h");
350 } else {
351 use_addr2line = false;
352 }
353
354 std::unique_ptr<Addr2linePipe> addr2line_state;
355
356 for (Backtrace::const_iterator it = backtrace->begin();
357 it != backtrace->end(); ++it) {
358 // We produce output like this:
359 // ] #00 pc 000075bb8 /system/lib/libc.so (unwind_backtrace_thread+536)
360 // In order for parsing tools to continue to function, the stack dump
361 // format must at least adhere to this format:
362 // #XX pc <RELATIVE_ADDR> <FULL_PATH_TO_SHARED_LIBRARY> ...
363 // The parsers require a single space before and after pc, and two spaces
364 // after the <RELATIVE_ADDR>. There can be any prefix data before the
365 // #XX. <RELATIVE_ADDR> has to be a hex number but with no 0x prefix.
366 os << prefix << StringPrintf("#%02zu pc ", it->num);
367 bool try_addr2line = false;
368 if (!BacktraceMap::IsValid(it->map)) {
369 os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIx64 " ???"
370 : "%08" PRIx64 " ???",
371 it->pc);
372 } else {
373 os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIx64 " "
374 : "%08" PRIx64 " ",
375 it->rel_pc);
376 if (it->map.name.empty()) {
377 os << StringPrintf("<anonymous:%" PRIx64 ">", it->map.start);
378 } else {
379 os << it->map.name;
380 }
381 if (it->map.offset != 0) {
382 os << StringPrintf(" (offset %" PRIx64 ")", it->map.offset);
383 }
384 os << " (";
385 if (!it->func_name.empty()) {
386 os << it->func_name;
387 if (it->func_offset != 0) {
388 os << "+" << it->func_offset;
389 }
390 // Functions found using the gdb jit interface will be in an empty
391 // map that cannot be found using addr2line.
392 if (!it->map.name.empty()) {
393 try_addr2line = true;
394 }
395 } else if (current_method != nullptr &&
396 Locks::mutator_lock_->IsSharedHeld(Thread::Current()) &&
397 PcIsWithinQuickCode(current_method, it->pc)) {
398 const void* start_of_code = current_method->GetEntryPointFromQuickCompiledCode();
399 os << current_method->JniLongName() << "+"
400 << (it->pc - reinterpret_cast<uint64_t>(start_of_code));
401 } else {
402 os << "???";
403 }
404 os << ")";
405 }
406 os << std::endl;
407 if (try_addr2line && use_addr2line) {
408 Addr2line(it->map.name, it->rel_pc, os, prefix, &addr2line_state);
409 }
410 }
411
412 if (addr2line_state != nullptr) {
413 Drain(0, prefix, &addr2line_state, os);
414 }
415 }
416
417 #elif defined(__APPLE__)
418
419 void DumpNativeStack(std::ostream& os ATTRIBUTE_UNUSED,
420 pid_t tid ATTRIBUTE_UNUSED,
421 BacktraceMap* existing_map ATTRIBUTE_UNUSED,
422 const char* prefix ATTRIBUTE_UNUSED,
423 ArtMethod* current_method ATTRIBUTE_UNUSED,
424 void* ucontext_ptr ATTRIBUTE_UNUSED,
425 bool skip_frames ATTRIBUTE_UNUSED) {
426 }
427
428 #else
429 #error "Unsupported architecture for native stack dumps."
430 #endif
431
432 } // namespace art
433