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