1 /*
2 * Copyright (C) 2012-2014 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 #define LOG_TAG "DEBUG"
18
19 #include <dirent.h>
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <inttypes.h>
23 #include <signal.h>
24 #include <stddef.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <time.h>
29 #include <sys/ptrace.h>
30 #include <sys/stat.h>
31
32 #include <memory>
33 #include <string>
34
35 #include <private/android_filesystem_config.h>
36
37 #include <android-base/stringprintf.h>
38 #include <cutils/properties.h>
39 #include <log/log.h>
40 #include <log/logger.h>
41 #include <log/logprint.h>
42
43 #include <backtrace/Backtrace.h>
44 #include <backtrace/BacktraceMap.h>
45
46 #include <selinux/android.h>
47
48 #include "backtrace.h"
49 #include "elf_utils.h"
50 #include "machine.h"
51 #include "tombstone.h"
52
53 #define STACK_WORDS 16
54
55 #define MAX_TOMBSTONES 10
56 #define TOMBSTONE_DIR "/data/tombstones"
57 #define TOMBSTONE_TEMPLATE (TOMBSTONE_DIR"/tombstone_%02d")
58
signal_has_si_addr(int sig)59 static bool signal_has_si_addr(int sig) {
60 switch (sig) {
61 case SIGBUS:
62 case SIGFPE:
63 case SIGILL:
64 case SIGSEGV:
65 case SIGTRAP:
66 return true;
67 default:
68 return false;
69 }
70 }
71
get_signame(int sig)72 static const char* get_signame(int sig) {
73 switch(sig) {
74 case SIGABRT: return "SIGABRT";
75 case SIGBUS: return "SIGBUS";
76 case SIGFPE: return "SIGFPE";
77 case SIGILL: return "SIGILL";
78 case SIGSEGV: return "SIGSEGV";
79 #if defined(SIGSTKFLT)
80 case SIGSTKFLT: return "SIGSTKFLT";
81 #endif
82 case SIGSTOP: return "SIGSTOP";
83 case SIGTRAP: return "SIGTRAP";
84 default: return "?";
85 }
86 }
87
get_sigcode(int signo,int code)88 static const char* get_sigcode(int signo, int code) {
89 // Try the signal-specific codes...
90 switch (signo) {
91 case SIGILL:
92 switch (code) {
93 case ILL_ILLOPC: return "ILL_ILLOPC";
94 case ILL_ILLOPN: return "ILL_ILLOPN";
95 case ILL_ILLADR: return "ILL_ILLADR";
96 case ILL_ILLTRP: return "ILL_ILLTRP";
97 case ILL_PRVOPC: return "ILL_PRVOPC";
98 case ILL_PRVREG: return "ILL_PRVREG";
99 case ILL_COPROC: return "ILL_COPROC";
100 case ILL_BADSTK: return "ILL_BADSTK";
101 }
102 static_assert(NSIGILL == ILL_BADSTK, "missing ILL_* si_code");
103 break;
104 case SIGBUS:
105 switch (code) {
106 case BUS_ADRALN: return "BUS_ADRALN";
107 case BUS_ADRERR: return "BUS_ADRERR";
108 case BUS_OBJERR: return "BUS_OBJERR";
109 case BUS_MCEERR_AR: return "BUS_MCEERR_AR";
110 case BUS_MCEERR_AO: return "BUS_MCEERR_AO";
111 }
112 static_assert(NSIGBUS == BUS_MCEERR_AO, "missing BUS_* si_code");
113 break;
114 case SIGFPE:
115 switch (code) {
116 case FPE_INTDIV: return "FPE_INTDIV";
117 case FPE_INTOVF: return "FPE_INTOVF";
118 case FPE_FLTDIV: return "FPE_FLTDIV";
119 case FPE_FLTOVF: return "FPE_FLTOVF";
120 case FPE_FLTUND: return "FPE_FLTUND";
121 case FPE_FLTRES: return "FPE_FLTRES";
122 case FPE_FLTINV: return "FPE_FLTINV";
123 case FPE_FLTSUB: return "FPE_FLTSUB";
124 }
125 static_assert(NSIGFPE == FPE_FLTSUB, "missing FPE_* si_code");
126 break;
127 case SIGSEGV:
128 switch (code) {
129 case SEGV_MAPERR: return "SEGV_MAPERR";
130 case SEGV_ACCERR: return "SEGV_ACCERR";
131 #if defined(SEGV_BNDERR)
132 case SEGV_BNDERR: return "SEGV_BNDERR";
133 #endif
134 }
135 #if defined(SEGV_BNDERR)
136 static_assert(NSIGSEGV == SEGV_BNDERR, "missing SEGV_* si_code");
137 #else
138 static_assert(NSIGSEGV == SEGV_ACCERR, "missing SEGV_* si_code");
139 #endif
140 break;
141 case SIGTRAP:
142 switch (code) {
143 case TRAP_BRKPT: return "TRAP_BRKPT";
144 case TRAP_TRACE: return "TRAP_TRACE";
145 case TRAP_BRANCH: return "TRAP_BRANCH";
146 case TRAP_HWBKPT: return "TRAP_HWBKPT";
147 }
148 static_assert(NSIGTRAP == TRAP_HWBKPT, "missing TRAP_* si_code");
149 break;
150 }
151 // Then the other codes...
152 switch (code) {
153 case SI_USER: return "SI_USER";
154 case SI_KERNEL: return "SI_KERNEL";
155 case SI_QUEUE: return "SI_QUEUE";
156 case SI_TIMER: return "SI_TIMER";
157 case SI_MESGQ: return "SI_MESGQ";
158 case SI_ASYNCIO: return "SI_ASYNCIO";
159 case SI_SIGIO: return "SI_SIGIO";
160 case SI_TKILL: return "SI_TKILL";
161 case SI_DETHREAD: return "SI_DETHREAD";
162 }
163 // Then give up...
164 return "?";
165 }
166
dump_header_info(log_t * log)167 static void dump_header_info(log_t* log) {
168 char fingerprint[PROPERTY_VALUE_MAX];
169 char revision[PROPERTY_VALUE_MAX];
170
171 property_get("ro.build.fingerprint", fingerprint, "unknown");
172 property_get("ro.revision", revision, "unknown");
173
174 _LOG(log, logtype::HEADER, "Build fingerprint: '%s'\n", fingerprint);
175 _LOG(log, logtype::HEADER, "Revision: '%s'\n", revision);
176 _LOG(log, logtype::HEADER, "ABI: '%s'\n", ABI_STRING);
177 }
178
dump_signal_info(log_t * log,pid_t tid,int signal,int si_code)179 static void dump_signal_info(log_t* log, pid_t tid, int signal, int si_code) {
180 siginfo_t si;
181 memset(&si, 0, sizeof(si));
182 if (ptrace(PTRACE_GETSIGINFO, tid, 0, &si) == -1) {
183 ALOGE("cannot get siginfo: %s\n", strerror(errno));
184 return;
185 }
186
187 // bionic has to re-raise some signals, which overwrites the si_code with SI_TKILL.
188 si.si_code = si_code;
189
190 char addr_desc[32]; // ", fault addr 0x1234"
191 if (signal_has_si_addr(signal)) {
192 snprintf(addr_desc, sizeof(addr_desc), "%p", si.si_addr);
193 } else {
194 snprintf(addr_desc, sizeof(addr_desc), "--------");
195 }
196
197 _LOG(log, logtype::HEADER, "signal %d (%s), code %d (%s), fault addr %s\n",
198 signal, get_signame(signal), si.si_code, get_sigcode(signal, si.si_code), addr_desc);
199 }
200
dump_thread_info(log_t * log,pid_t pid,pid_t tid)201 static void dump_thread_info(log_t* log, pid_t pid, pid_t tid) {
202 char path[64];
203 char threadnamebuf[1024];
204 char* threadname = nullptr;
205 FILE *fp;
206
207 snprintf(path, sizeof(path), "/proc/%d/comm", tid);
208 if ((fp = fopen(path, "r"))) {
209 threadname = fgets(threadnamebuf, sizeof(threadnamebuf), fp);
210 fclose(fp);
211 if (threadname) {
212 size_t len = strlen(threadname);
213 if (len && threadname[len - 1] == '\n') {
214 threadname[len - 1] = '\0';
215 }
216 }
217 }
218 // Blacklist logd, logd.reader, logd.writer, logd.auditd, logd.control ...
219 static const char logd[] = "logd";
220 if (threadname != nullptr && !strncmp(threadname, logd, sizeof(logd) - 1)
221 && (!threadname[sizeof(logd) - 1] || (threadname[sizeof(logd) - 1] == '.'))) {
222 log->should_retrieve_logcat = false;
223 }
224
225 char procnamebuf[1024];
226 char* procname = nullptr;
227
228 snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
229 if ((fp = fopen(path, "r"))) {
230 procname = fgets(procnamebuf, sizeof(procnamebuf), fp);
231 fclose(fp);
232 }
233
234 _LOG(log, logtype::HEADER, "pid: %d, tid: %d, name: %s >>> %s <<<\n", pid, tid,
235 threadname ? threadname : "UNKNOWN", procname ? procname : "UNKNOWN");
236 }
237
dump_stack_segment(Backtrace * backtrace,log_t * log,uintptr_t * sp,size_t words,int label)238 static void dump_stack_segment(
239 Backtrace* backtrace, log_t* log, uintptr_t* sp, size_t words, int label) {
240 // Read the data all at once.
241 word_t stack_data[words];
242 size_t bytes_read = backtrace->Read(*sp, reinterpret_cast<uint8_t*>(&stack_data[0]), sizeof(word_t) * words);
243 words = bytes_read / sizeof(word_t);
244 std::string line;
245 for (size_t i = 0; i < words; i++) {
246 line = " ";
247 if (i == 0 && label >= 0) {
248 // Print the label once.
249 line += android::base::StringPrintf("#%02d ", label);
250 } else {
251 line += " ";
252 }
253 line += android::base::StringPrintf("%" PRIPTR " %" PRIPTR, *sp, stack_data[i]);
254
255 backtrace_map_t map;
256 backtrace->FillInMap(stack_data[i], &map);
257 if (BacktraceMap::IsValid(map) && !map.name.empty()) {
258 line += " " + map.name;
259 uintptr_t offset = 0;
260 std::string func_name(backtrace->GetFunctionName(stack_data[i], &offset));
261 if (!func_name.empty()) {
262 line += " (" + func_name;
263 if (offset) {
264 line += android::base::StringPrintf("+%" PRIuPTR, offset);
265 }
266 line += ')';
267 }
268 }
269 _LOG(log, logtype::STACK, "%s\n", line.c_str());
270
271 *sp += sizeof(word_t);
272 }
273 }
274
dump_stack(Backtrace * backtrace,log_t * log)275 static void dump_stack(Backtrace* backtrace, log_t* log) {
276 size_t first = 0, last;
277 for (size_t i = 0; i < backtrace->NumFrames(); i++) {
278 const backtrace_frame_data_t* frame = backtrace->GetFrame(i);
279 if (frame->sp) {
280 if (!first) {
281 first = i+1;
282 }
283 last = i;
284 }
285 }
286 if (!first) {
287 return;
288 }
289 first--;
290
291 // Dump a few words before the first frame.
292 word_t sp = backtrace->GetFrame(first)->sp - STACK_WORDS * sizeof(word_t);
293 dump_stack_segment(backtrace, log, &sp, STACK_WORDS, -1);
294
295 // Dump a few words from all successive frames.
296 // Only log the first 3 frames, put the rest in the tombstone.
297 for (size_t i = first; i <= last; i++) {
298 const backtrace_frame_data_t* frame = backtrace->GetFrame(i);
299 if (sp != frame->sp) {
300 _LOG(log, logtype::STACK, " ........ ........\n");
301 sp = frame->sp;
302 }
303 if (i == last) {
304 dump_stack_segment(backtrace, log, &sp, STACK_WORDS, i);
305 if (sp < frame->sp + frame->stack_size) {
306 _LOG(log, logtype::STACK, " ........ ........\n");
307 }
308 } else {
309 size_t words = frame->stack_size / sizeof(word_t);
310 if (words == 0) {
311 words = 1;
312 } else if (words > STACK_WORDS) {
313 words = STACK_WORDS;
314 }
315 dump_stack_segment(backtrace, log, &sp, words, i);
316 }
317 }
318 }
319
get_addr_string(uintptr_t addr)320 static std::string get_addr_string(uintptr_t addr) {
321 std::string addr_str;
322 #if defined(__LP64__)
323 addr_str = android::base::StringPrintf("%08x'%08x",
324 static_cast<uint32_t>(addr >> 32),
325 static_cast<uint32_t>(addr & 0xffffffff));
326 #else
327 addr_str = android::base::StringPrintf("%08x", addr);
328 #endif
329 return addr_str;
330 }
331
dump_abort_message(Backtrace * backtrace,log_t * log,uintptr_t address)332 static void dump_abort_message(Backtrace* backtrace, log_t* log, uintptr_t address) {
333 if (address == 0) {
334 return;
335 }
336
337 address += sizeof(size_t); // Skip the buffer length.
338
339 char msg[512];
340 memset(msg, 0, sizeof(msg));
341 char* p = &msg[0];
342 while (p < &msg[sizeof(msg)]) {
343 word_t data;
344 size_t len = sizeof(word_t);
345 if (!backtrace->ReadWord(address, &data)) {
346 break;
347 }
348 address += sizeof(word_t);
349
350 while (len > 0 && (*p++ = (data >> (sizeof(word_t) - len) * 8) & 0xff) != 0) {
351 len--;
352 }
353 }
354 msg[sizeof(msg) - 1] = '\0';
355
356 _LOG(log, logtype::HEADER, "Abort message: '%s'\n", msg);
357 }
358
dump_all_maps(Backtrace * backtrace,BacktraceMap * map,log_t * log,pid_t tid)359 static void dump_all_maps(Backtrace* backtrace, BacktraceMap* map, log_t* log, pid_t tid) {
360 bool print_fault_address_marker = false;
361 uintptr_t addr = 0;
362 siginfo_t si;
363 memset(&si, 0, sizeof(si));
364 if (ptrace(PTRACE_GETSIGINFO, tid, 0, &si) != -1) {
365 print_fault_address_marker = signal_has_si_addr(si.si_signo);
366 addr = reinterpret_cast<uintptr_t>(si.si_addr);
367 } else {
368 ALOGE("Cannot get siginfo for %d: %s\n", tid, strerror(errno));
369 }
370
371 ScopedBacktraceMapIteratorLock lock(map);
372 _LOG(log, logtype::MAPS, "\n");
373 if (!print_fault_address_marker) {
374 _LOG(log, logtype::MAPS, "memory map:\n");
375 } else {
376 _LOG(log, logtype::MAPS, "memory map: (fault address prefixed with --->)\n");
377 if (map->begin() != map->end() && addr < map->begin()->start) {
378 _LOG(log, logtype::MAPS, "--->Fault address falls at %s before any mapped regions\n",
379 get_addr_string(addr).c_str());
380 print_fault_address_marker = false;
381 }
382 }
383
384 std::string line;
385 for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) {
386 line = " ";
387 if (print_fault_address_marker) {
388 if (addr < it->start) {
389 _LOG(log, logtype::MAPS, "--->Fault address falls at %s between mapped regions\n",
390 get_addr_string(addr).c_str());
391 print_fault_address_marker = false;
392 } else if (addr >= it->start && addr < it->end) {
393 line = "--->";
394 print_fault_address_marker = false;
395 }
396 }
397 line += get_addr_string(it->start) + '-' + get_addr_string(it->end - 1) + ' ';
398 if (it->flags & PROT_READ) {
399 line += 'r';
400 } else {
401 line += '-';
402 }
403 if (it->flags & PROT_WRITE) {
404 line += 'w';
405 } else {
406 line += '-';
407 }
408 if (it->flags & PROT_EXEC) {
409 line += 'x';
410 } else {
411 line += '-';
412 }
413 line += android::base::StringPrintf(" %8" PRIxPTR " %8" PRIxPTR,
414 it->offset, it->end - it->start);
415 bool space_needed = true;
416 if (it->name.length() > 0) {
417 space_needed = false;
418 line += " " + it->name;
419 std::string build_id;
420 if ((it->flags & PROT_READ) && elf_get_build_id(backtrace, it->start, &build_id)) {
421 line += " (BuildId: " + build_id + ")";
422 }
423 }
424 if (it->load_base != 0) {
425 if (space_needed) {
426 line += ' ';
427 }
428 line += android::base::StringPrintf(" (load base 0x%" PRIxPTR ")", it->load_base);
429 }
430 _LOG(log, logtype::MAPS, "%s\n", line.c_str());
431 }
432 if (print_fault_address_marker) {
433 _LOG(log, logtype::MAPS, "--->Fault address falls at %s after any mapped regions\n",
434 get_addr_string(addr).c_str());
435 }
436 }
437
dump_backtrace_and_stack(Backtrace * backtrace,log_t * log)438 static void dump_backtrace_and_stack(Backtrace* backtrace, log_t* log) {
439 if (backtrace->NumFrames()) {
440 _LOG(log, logtype::BACKTRACE, "\nbacktrace:\n");
441 dump_backtrace_to_log(backtrace, log, " ");
442
443 _LOG(log, logtype::STACK, "\nstack:\n");
444 dump_stack(backtrace, log);
445 }
446 }
447
dump_thread(log_t * log,pid_t pid,pid_t tid,BacktraceMap * map,int signal,int si_code,uintptr_t abort_msg_address,bool primary_thread)448 static void dump_thread(log_t* log, pid_t pid, pid_t tid, BacktraceMap* map, int signal,
449 int si_code, uintptr_t abort_msg_address, bool primary_thread) {
450 log->current_tid = tid;
451 if (!primary_thread) {
452 _LOG(log, logtype::THREAD, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
453 }
454 dump_thread_info(log, pid, tid);
455
456 if (signal) {
457 dump_signal_info(log, tid, signal, si_code);
458 }
459
460 std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, tid, map));
461 if (primary_thread) {
462 dump_abort_message(backtrace.get(), log, abort_msg_address);
463 }
464 dump_registers(log, tid);
465 if (backtrace->Unwind(0)) {
466 dump_backtrace_and_stack(backtrace.get(), log);
467 } else {
468 ALOGE("Unwind failed: pid = %d, tid = %d", pid, tid);
469 }
470
471 if (primary_thread) {
472 dump_memory_and_code(log, backtrace.get());
473 if (map) {
474 dump_all_maps(backtrace.get(), map, log, tid);
475 }
476 }
477
478 log->current_tid = log->crashed_tid;
479 }
480
481 // Reads the contents of the specified log device, filters out the entries
482 // that don't match the specified pid, and writes them to the tombstone file.
483 //
484 // If "tail" is non-zero, log the last "tail" number of lines.
485 static EventTagMap* g_eventTagMap = NULL;
486
dump_log_file(log_t * log,pid_t pid,const char * filename,unsigned int tail)487 static void dump_log_file(
488 log_t* log, pid_t pid, const char* filename, unsigned int tail) {
489 bool first = true;
490 struct logger_list* logger_list;
491
492 if (!log->should_retrieve_logcat) {
493 return;
494 }
495
496 logger_list = android_logger_list_open(
497 android_name_to_log_id(filename), ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, tail, pid);
498
499 if (!logger_list) {
500 ALOGE("Unable to open %s: %s\n", filename, strerror(errno));
501 return;
502 }
503
504 struct log_msg log_entry;
505
506 while (true) {
507 ssize_t actual = android_logger_list_read(logger_list, &log_entry);
508 struct logger_entry* entry;
509
510 if (actual < 0) {
511 if (actual == -EINTR) {
512 // interrupted by signal, retry
513 continue;
514 } else if (actual == -EAGAIN) {
515 // non-blocking EOF; we're done
516 break;
517 } else {
518 ALOGE("Error while reading log: %s\n", strerror(-actual));
519 break;
520 }
521 } else if (actual == 0) {
522 ALOGE("Got zero bytes while reading log: %s\n", strerror(errno));
523 break;
524 }
525
526 // NOTE: if you ALOGV something here, this will spin forever,
527 // because you will be writing as fast as you're reading. Any
528 // high-frequency debug diagnostics should just be written to
529 // the tombstone file.
530
531 entry = &log_entry.entry_v1;
532
533 if (first) {
534 _LOG(log, logtype::LOGS, "--------- %slog %s\n",
535 tail ? "tail end of " : "", filename);
536 first = false;
537 }
538
539 // Msg format is: <priority:1><tag:N>\0<message:N>\0
540 //
541 // We want to display it in the same format as "logcat -v threadtime"
542 // (although in this case the pid is redundant).
543 static const char* kPrioChars = "!.VDIWEFS";
544 unsigned hdr_size = log_entry.entry.hdr_size;
545 if (!hdr_size) {
546 hdr_size = sizeof(log_entry.entry_v1);
547 }
548 char* msg = reinterpret_cast<char*>(log_entry.buf) + hdr_size;
549
550 char timeBuf[32];
551 time_t sec = static_cast<time_t>(entry->sec);
552 struct tm tmBuf;
553 struct tm* ptm;
554 ptm = localtime_r(&sec, &tmBuf);
555 strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm);
556
557 if (log_entry.id() == LOG_ID_EVENTS) {
558 if (!g_eventTagMap) {
559 g_eventTagMap = android_openEventTagMap(EVENT_TAG_MAP_FILE);
560 }
561 AndroidLogEntry e;
562 char buf[512];
563 android_log_processBinaryLogBuffer(entry, &e, g_eventTagMap, buf, sizeof(buf));
564 _LOG(log, logtype::LOGS, "%s.%03d %5d %5d %c %-8s: %s\n",
565 timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
566 'I', e.tag, e.message);
567 continue;
568 }
569
570 unsigned char prio = msg[0];
571 char* tag = msg + 1;
572 msg = tag + strlen(tag) + 1;
573
574 // consume any trailing newlines
575 char* nl = msg + strlen(msg) - 1;
576 while (nl >= msg && *nl == '\n') {
577 *nl-- = '\0';
578 }
579
580 char prioChar = (prio < strlen(kPrioChars) ? kPrioChars[prio] : '?');
581
582 // Look for line breaks ('\n') and display each text line
583 // on a separate line, prefixed with the header, like logcat does.
584 do {
585 nl = strchr(msg, '\n');
586 if (nl) {
587 *nl = '\0';
588 ++nl;
589 }
590
591 _LOG(log, logtype::LOGS, "%s.%03d %5d %5d %c %-8s: %s\n",
592 timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
593 prioChar, tag, msg);
594 } while ((msg = nl));
595 }
596
597 android_logger_list_free(logger_list);
598 }
599
600 // Dumps the logs generated by the specified pid to the tombstone, from both
601 // "system" and "main" log devices. Ideally we'd interleave the output.
dump_logs(log_t * log,pid_t pid,unsigned int tail)602 static void dump_logs(log_t* log, pid_t pid, unsigned int tail) {
603 dump_log_file(log, pid, "system", tail);
604 dump_log_file(log, pid, "main", tail);
605 }
606
607 // Dumps all information about the specified pid to the tombstone.
dump_crash(log_t * log,BacktraceMap * map,pid_t pid,pid_t tid,const std::set<pid_t> & siblings,int signal,int si_code,uintptr_t abort_msg_address)608 static void dump_crash(log_t* log, BacktraceMap* map, pid_t pid, pid_t tid,
609 const std::set<pid_t>& siblings, int signal, int si_code,
610 uintptr_t abort_msg_address) {
611 // don't copy log messages to tombstone unless this is a dev device
612 char value[PROPERTY_VALUE_MAX];
613 property_get("ro.debuggable", value, "0");
614 bool want_logs = (value[0] == '1');
615
616 _LOG(log, logtype::HEADER,
617 "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
618 dump_header_info(log);
619 dump_thread(log, pid, tid, map, signal, si_code, abort_msg_address, true);
620 if (want_logs) {
621 dump_logs(log, pid, 5);
622 }
623
624 if (!siblings.empty()) {
625 for (pid_t sibling : siblings) {
626 dump_thread(log, pid, sibling, map, 0, 0, 0, false);
627 }
628 }
629
630 if (want_logs) {
631 dump_logs(log, pid, 0);
632 }
633 }
634
635 // open_tombstone - find an available tombstone slot, if any, of the
636 // form tombstone_XX where XX is 00 to MAX_TOMBSTONES-1, inclusive. If no
637 // file is available, we reuse the least-recently-modified file.
open_tombstone(std::string * out_path)638 int open_tombstone(std::string* out_path) {
639 // In a single pass, find an available slot and, in case none
640 // exist, find and record the least-recently-modified file.
641 char path[128];
642 int fd = -1;
643 int oldest = -1;
644 struct stat oldest_sb;
645 for (int i = 0; i < MAX_TOMBSTONES; i++) {
646 snprintf(path, sizeof(path), TOMBSTONE_TEMPLATE, i);
647
648 struct stat sb;
649 if (stat(path, &sb) == 0) {
650 if (oldest < 0 || sb.st_mtime < oldest_sb.st_mtime) {
651 oldest = i;
652 oldest_sb.st_mtime = sb.st_mtime;
653 }
654 continue;
655 }
656 if (errno != ENOENT) continue;
657
658 fd = open(path, O_CREAT | O_EXCL | O_WRONLY | O_NOFOLLOW | O_CLOEXEC, 0600);
659 if (fd < 0) continue; // raced ?
660
661 if (out_path) {
662 *out_path = path;
663 }
664 fchown(fd, AID_SYSTEM, AID_SYSTEM);
665 return fd;
666 }
667
668 if (oldest < 0) {
669 ALOGE("debuggerd: failed to find a valid tombstone, default to using tombstone 0.\n");
670 oldest = 0;
671 }
672
673 // we didn't find an available file, so we clobber the oldest one
674 snprintf(path, sizeof(path), TOMBSTONE_TEMPLATE, oldest);
675 fd = open(path, O_CREAT | O_TRUNC | O_WRONLY | O_NOFOLLOW | O_CLOEXEC, 0600);
676 if (fd < 0) {
677 ALOGE("debuggerd: failed to open tombstone file '%s': %s\n", path, strerror(errno));
678 return -1;
679 }
680
681 if (out_path) {
682 *out_path = path;
683 }
684 fchown(fd, AID_SYSTEM, AID_SYSTEM);
685 return fd;
686 }
687
engrave_tombstone(int tombstone_fd,BacktraceMap * map,pid_t pid,pid_t tid,const std::set<pid_t> & siblings,int signal,int original_si_code,uintptr_t abort_msg_address,std::string * amfd_data)688 void engrave_tombstone(int tombstone_fd, BacktraceMap* map, pid_t pid, pid_t tid,
689 const std::set<pid_t>& siblings, int signal, int original_si_code,
690 uintptr_t abort_msg_address, std::string* amfd_data) {
691 log_t log;
692 log.current_tid = tid;
693 log.crashed_tid = tid;
694
695 if (tombstone_fd < 0) {
696 ALOGE("debuggerd: skipping tombstone write, nothing to do.\n");
697 return;
698 }
699
700 log.tfd = tombstone_fd;
701 log.amfd_data = amfd_data;
702 dump_crash(&log, map, pid, tid, siblings, signal, original_si_code, abort_msg_address);
703 }
704