tombstone.cpp revision 290efd244d8af18811b2ef2dac8f30cc7a37e066
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#include <stddef.h> 18#include <stdlib.h> 19#include <signal.h> 20#include <string.h> 21#include <stdio.h> 22#include <fcntl.h> 23#include <errno.h> 24#include <dirent.h> 25#include <time.h> 26#include <sys/ptrace.h> 27#include <sys/stat.h> 28#include <inttypes.h> 29 30#include <private/android_filesystem_config.h> 31 32#include <log/log.h> 33#include <log/logger.h> 34#include <cutils/properties.h> 35 36#include <backtrace/Backtrace.h> 37#include <backtrace/BacktraceMap.h> 38 39#include <sys/socket.h> 40#include <linux/un.h> 41 42#include <selinux/android.h> 43 44#include <UniquePtr.h> 45 46#include "machine.h" 47#include "tombstone.h" 48#include "backtrace.h" 49 50#define STACK_WORDS 16 51 52#define MAX_TOMBSTONES 10 53#define TOMBSTONE_DIR "/data/tombstones" 54 55// Must match the path defined in NativeCrashListener.java 56#define NCRASH_SOCKET_PATH "/data/system/ndebugsocket" 57 58#define typecheck(x,y) { \ 59 typeof(x) __dummy1; \ 60 typeof(y) __dummy2; \ 61 (void)(&__dummy1 == &__dummy2); } 62 63 64static bool signal_has_address(int sig) { 65 switch (sig) { 66 case SIGILL: 67 case SIGFPE: 68 case SIGSEGV: 69 case SIGBUS: 70 return true; 71 default: 72 return false; 73 } 74} 75 76static const char* get_signame(int sig) { 77 switch(sig) { 78 case SIGILL: return "SIGILL"; 79 case SIGABRT: return "SIGABRT"; 80 case SIGBUS: return "SIGBUS"; 81 case SIGFPE: return "SIGFPE"; 82 case SIGSEGV: return "SIGSEGV"; 83 case SIGPIPE: return "SIGPIPE"; 84#ifdef SIGSTKFLT 85 case SIGSTKFLT: return "SIGSTKFLT"; 86#endif 87 case SIGSTOP: return "SIGSTOP"; 88 default: return "?"; 89 } 90} 91 92static const char* get_sigcode(int signo, int code) { 93 // Try the signal-specific codes... 94 switch (signo) { 95 case SIGILL: 96 switch (code) { 97 case ILL_ILLOPC: return "ILL_ILLOPC"; 98 case ILL_ILLOPN: return "ILL_ILLOPN"; 99 case ILL_ILLADR: return "ILL_ILLADR"; 100 case ILL_ILLTRP: return "ILL_ILLTRP"; 101 case ILL_PRVOPC: return "ILL_PRVOPC"; 102 case ILL_PRVREG: return "ILL_PRVREG"; 103 case ILL_COPROC: return "ILL_COPROC"; 104 case ILL_BADSTK: return "ILL_BADSTK"; 105 } 106 break; 107 case SIGBUS: 108 switch (code) { 109 case BUS_ADRALN: return "BUS_ADRALN"; 110 case BUS_ADRERR: return "BUS_ADRERR"; 111 case BUS_OBJERR: return "BUS_OBJERR"; 112 } 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 break; 126 case SIGSEGV: 127 switch (code) { 128 case SEGV_MAPERR: return "SEGV_MAPERR"; 129 case SEGV_ACCERR: return "SEGV_ACCERR"; 130 } 131 break; 132 case SIGTRAP: 133 switch (code) { 134 case TRAP_BRKPT: return "TRAP_BRKPT"; 135 case TRAP_TRACE: return "TRAP_TRACE"; 136 } 137 break; 138 } 139 // Then the other codes... 140 switch (code) { 141 case SI_USER: return "SI_USER"; 142#if defined(SI_KERNEL) 143 case SI_KERNEL: return "SI_KERNEL"; 144#endif 145 case SI_QUEUE: return "SI_QUEUE"; 146 case SI_TIMER: return "SI_TIMER"; 147 case SI_MESGQ: return "SI_MESGQ"; 148 case SI_ASYNCIO: return "SI_ASYNCIO"; 149#if defined(SI_SIGIO) 150 case SI_SIGIO: return "SI_SIGIO"; 151#endif 152#if defined(SI_TKILL) 153 case SI_TKILL: return "SI_TKILL"; 154#endif 155 } 156 // Then give up... 157 return "?"; 158} 159 160static void dump_revision_info(log_t* log) { 161 char revision[PROPERTY_VALUE_MAX]; 162 163 property_get("ro.revision", revision, "unknown"); 164 165 _LOG(log, SCOPE_AT_FAULT, "Revision: '%s'\n", revision); 166} 167 168static void dump_build_info(log_t* log) { 169 char fingerprint[PROPERTY_VALUE_MAX]; 170 171 property_get("ro.build.fingerprint", fingerprint, "unknown"); 172 173 _LOG(log, SCOPE_AT_FAULT, "Build fingerprint: '%s'\n", fingerprint); 174} 175 176static void dump_fault_addr(log_t* log, pid_t tid, int sig) { 177 siginfo_t si; 178 179 memset(&si, 0, sizeof(si)); 180 if (ptrace(PTRACE_GETSIGINFO, tid, 0, &si)){ 181 _LOG(log, SCOPE_AT_FAULT, "cannot get siginfo: %s\n", strerror(errno)); 182 } else if (signal_has_address(sig)) { 183 _LOG(log, SCOPE_AT_FAULT, "signal %d (%s), code %d (%s), fault addr %0*" PRIxPTR "\n", 184 sig, get_signame(sig), si.si_code, get_sigcode(sig, si.si_code), 185 sizeof(uintptr_t)*2, reinterpret_cast<uintptr_t>(si.si_addr)); 186 } else { 187 _LOG(log, SCOPE_AT_FAULT, "signal %d (%s), code %d (%s), fault addr --------\n", 188 sig, get_signame(sig), si.si_code, get_sigcode(sig, si.si_code)); 189 } 190} 191 192static void dump_thread_info(log_t* log, pid_t pid, pid_t tid, int scope_flags) { 193 char path[64]; 194 char threadnamebuf[1024]; 195 char* threadname = NULL; 196 FILE *fp; 197 198 snprintf(path, sizeof(path), "/proc/%d/comm", tid); 199 if ((fp = fopen(path, "r"))) { 200 threadname = fgets(threadnamebuf, sizeof(threadnamebuf), fp); 201 fclose(fp); 202 if (threadname) { 203 size_t len = strlen(threadname); 204 if (len && threadname[len - 1] == '\n') { 205 threadname[len - 1] = '\0'; 206 } 207 } 208 } 209 210 if (IS_AT_FAULT(scope_flags)) { 211 char procnamebuf[1024]; 212 char* procname = NULL; 213 214 snprintf(path, sizeof(path), "/proc/%d/cmdline", pid); 215 if ((fp = fopen(path, "r"))) { 216 procname = fgets(procnamebuf, sizeof(procnamebuf), fp); 217 fclose(fp); 218 } 219 220 _LOG(log, SCOPE_AT_FAULT, "pid: %d, tid: %d, name: %s >>> %s <<<\n", pid, tid, 221 threadname ? threadname : "UNKNOWN", procname ? procname : "UNKNOWN"); 222 } else { 223 _LOG(log, 0, "pid: %d, tid: %d, name: %s\n", pid, tid, threadname ? threadname : "UNKNOWN"); 224 } 225} 226 227static void dump_stack_segment( 228 Backtrace* backtrace, log_t* log, int scope_flags, uintptr_t* sp, size_t words, int label) { 229 for (size_t i = 0; i < words; i++) { 230 uint32_t stack_content; 231 if (!backtrace->ReadWord(*sp, &stack_content)) { 232 break; 233 } 234 235 const backtrace_map_t* map = backtrace->FindMap(stack_content); 236 const char* map_name; 237 if (!map) { 238 map_name = ""; 239 } else { 240 map_name = map->name.c_str(); 241 } 242 uintptr_t offset = 0; 243 std::string func_name(backtrace->GetFunctionName(stack_content, &offset)); 244 if (!func_name.empty()) { 245 if (!i && label >= 0) { 246 if (offset) { 247 _LOG(log, scope_flags, " #%02d %08x %08x %s (%s+%u)\n", 248 label, *sp, stack_content, map_name, func_name.c_str(), offset); 249 } else { 250 _LOG(log, scope_flags, " #%02d %08x %08x %s (%s)\n", 251 label, *sp, stack_content, map_name, func_name.c_str()); 252 } 253 } else { 254 if (offset) { 255 _LOG(log, scope_flags, " %08x %08x %s (%s+%u)\n", 256 *sp, stack_content, map_name, func_name.c_str(), offset); 257 } else { 258 _LOG(log, scope_flags, " %08x %08x %s (%s)\n", 259 *sp, stack_content, map_name, func_name.c_str()); 260 } 261 } 262 } else { 263 if (!i && label >= 0) { 264 _LOG(log, scope_flags, " #%02d %08x %08x %s\n", 265 label, *sp, stack_content, map_name); 266 } else { 267 _LOG(log, scope_flags, " %08x %08x %s\n", 268 *sp, stack_content, map_name); 269 } 270 } 271 272 *sp += sizeof(uint32_t); 273 } 274} 275 276static void dump_stack(Backtrace* backtrace, log_t* log, int scope_flags) { 277 size_t first = 0, last; 278 for (size_t i = 0; i < backtrace->NumFrames(); i++) { 279 const backtrace_frame_data_t* frame = backtrace->GetFrame(i); 280 if (frame->sp) { 281 if (!first) { 282 first = i+1; 283 } 284 last = i; 285 } 286 } 287 if (!first) { 288 return; 289 } 290 first--; 291 292 scope_flags |= SCOPE_SENSITIVE; 293 294 // Dump a few words before the first frame. 295 uintptr_t sp = backtrace->GetFrame(first)->sp - STACK_WORDS * sizeof(uint32_t); 296 dump_stack_segment(backtrace, log, scope_flags, &sp, STACK_WORDS, -1); 297 298 // Dump a few words from all successive frames. 299 // Only log the first 3 frames, put the rest in the tombstone. 300 for (size_t i = first; i <= last; i++) { 301 const backtrace_frame_data_t* frame = backtrace->GetFrame(i); 302 if (sp != frame->sp) { 303 _LOG(log, scope_flags, " ........ ........\n"); 304 sp = frame->sp; 305 } 306 if (i - first == 3) { 307 scope_flags &= (~SCOPE_AT_FAULT); 308 } 309 if (i == last) { 310 dump_stack_segment(backtrace, log, scope_flags, &sp, STACK_WORDS, i); 311 if (sp < frame->sp + frame->stack_size) { 312 _LOG(log, scope_flags, " ........ ........\n"); 313 } 314 } else { 315 size_t words = frame->stack_size / sizeof(uint32_t); 316 if (words == 0) { 317 words = 1; 318 } else if (words > STACK_WORDS) { 319 words = STACK_WORDS; 320 } 321 dump_stack_segment(backtrace, log, scope_flags, &sp, words, i); 322 } 323 } 324} 325 326static void dump_backtrace_and_stack(Backtrace* backtrace, log_t* log, int scope_flags) { 327 if (backtrace->NumFrames()) { 328 _LOG(log, scope_flags, "\nbacktrace:\n"); 329 dump_backtrace_to_log(backtrace, log, scope_flags, " "); 330 331 _LOG(log, scope_flags, "\nstack:\n"); 332 dump_stack(backtrace, log, scope_flags); 333 } 334} 335 336static void dump_map(log_t* log, const backtrace_map_t* map, const char* what, int scope_flags) { 337 if (map != NULL) { 338 _LOG(log, scope_flags, " %08x-%08x %c%c%c %s\n", map->start, map->end, 339 (map->flags & PROT_READ) ? 'r' : '-', (map->flags & PROT_WRITE) ? 'w' : '-', 340 (map->flags & PROT_EXEC) ? 'x' : '-', map->name.c_str()); 341 } else { 342 _LOG(log, scope_flags, " (no %s)\n", what); 343 } 344} 345 346static void dump_nearby_maps(BacktraceMap* map, log_t* log, pid_t tid, int scope_flags) { 347 scope_flags |= SCOPE_SENSITIVE; 348 siginfo_t si; 349 memset(&si, 0, sizeof(si)); 350 if (ptrace(PTRACE_GETSIGINFO, tid, 0, &si)) { 351 _LOG(log, scope_flags, "cannot get siginfo for %d: %s\n", tid, strerror(errno)); 352 return; 353 } 354 if (!signal_has_address(si.si_signo)) { 355 return; 356 } 357 358 uintptr_t addr = reinterpret_cast<uintptr_t>(si.si_addr); 359 addr &= ~0xfff; // round to 4K page boundary 360 if (addr == 0) { // null-pointer deref 361 return; 362 } 363 364 _LOG(log, scope_flags, "\nmemory map around fault addr %" PRIxPTR ":\n", 365 reinterpret_cast<uintptr_t>(si.si_addr)); 366 367 // Search for a match, or for a hole where the match would be. The list 368 // is backward from the file content, so it starts at high addresses. 369 const backtrace_map_t* cur_map = NULL; 370 const backtrace_map_t* next_map = NULL; 371 const backtrace_map_t* prev_map = NULL; 372 for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) { 373 if (addr >= it->start && addr < it->end) { 374 cur_map = &*it; 375 if (it != map->begin()) { 376 prev_map = &*(it-1); 377 } 378 if (++it != map->end()) { 379 next_map = &*it; 380 } 381 break; 382 } 383 } 384 385 // Show the map address in ascending order (like /proc/pid/maps). 386 dump_map(log, prev_map, "map below", scope_flags); 387 dump_map(log, cur_map, "map for address", scope_flags); 388 dump_map(log, next_map, "map above", scope_flags); 389} 390 391static void dump_thread( 392 Backtrace* backtrace, log_t* log, int scope_flags, int* total_sleep_time_usec) { 393 wait_for_stop(backtrace->Tid(), total_sleep_time_usec); 394 395 dump_registers(log, backtrace->Tid(), scope_flags); 396 dump_backtrace_and_stack(backtrace, log, scope_flags); 397 if (IS_AT_FAULT(scope_flags)) { 398 dump_memory_and_code(log, backtrace->Tid(), scope_flags); 399 dump_nearby_maps(backtrace->GetMap(), log, backtrace->Tid(), scope_flags); 400 } 401} 402 403// Return true if some thread is not detached cleanly 404static bool dump_sibling_thread_report( 405 log_t* log, pid_t pid, pid_t tid, int* total_sleep_time_usec, BacktraceMap* map) { 406 char task_path[64]; 407 snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid); 408 409 DIR* d = opendir(task_path); 410 // Bail early if the task directory cannot be opened 411 if (d == NULL) { 412 XLOG("Cannot open /proc/%d/task\n", pid); 413 return false; 414 } 415 416 bool detach_failed = false; 417 struct dirent* de; 418 while ((de = readdir(d)) != NULL) { 419 // Ignore "." and ".." 420 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) { 421 continue; 422 } 423 424 // The main thread at fault has been handled individually 425 char* end; 426 pid_t new_tid = strtoul(de->d_name, &end, 10); 427 if (*end || new_tid == tid) { 428 continue; 429 } 430 431 // Skip this thread if cannot ptrace it 432 if (ptrace(PTRACE_ATTACH, new_tid, 0, 0) < 0) { 433 continue; 434 } 435 436 _LOG(log, 0, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n"); 437 dump_thread_info(log, pid, new_tid, 0); 438 439 UniquePtr<Backtrace> backtrace(Backtrace::Create(pid, new_tid, map)); 440 if (backtrace->Unwind(0)) { 441 dump_thread(backtrace.get(), log, 0, total_sleep_time_usec); 442 } 443 444 if (ptrace(PTRACE_DETACH, new_tid, 0, 0) != 0) { 445 LOG("ptrace detach from %d failed: %s\n", new_tid, strerror(errno)); 446 detach_failed = true; 447 } 448 } 449 450 closedir(d); 451 return detach_failed; 452} 453 454// Reads the contents of the specified log device, filters out the entries 455// that don't match the specified pid, and writes them to the tombstone file. 456// 457// If "tail" is set, we only print the last few lines. 458static void dump_log_file(log_t* log, pid_t pid, const char* filename, 459 unsigned int tail) { 460 bool first = true; 461 struct logger_list *logger_list; 462 463 logger_list = android_logger_list_open( 464 android_name_to_log_id(filename), O_RDONLY | O_NONBLOCK, tail, pid); 465 466 if (!logger_list) { 467 XLOG("Unable to open %s: %s\n", filename, strerror(errno)); 468 return; 469 } 470 471 struct log_msg log_entry; 472 473 while (true) { 474 ssize_t actual = android_logger_list_read(logger_list, &log_entry); 475 476 if (actual < 0) { 477 if (actual == -EINTR) { 478 // interrupted by signal, retry 479 continue; 480 } else if (actual == -EAGAIN) { 481 // non-blocking EOF; we're done 482 break; 483 } else { 484 _LOG(log, 0, "Error while reading log: %s\n", 485 strerror(-actual)); 486 break; 487 } 488 } else if (actual == 0) { 489 _LOG(log, 0, "Got zero bytes while reading log: %s\n", 490 strerror(errno)); 491 break; 492 } 493 494 // NOTE: if you XLOG something here, this will spin forever, 495 // because you will be writing as fast as you're reading. Any 496 // high-frequency debug diagnostics should just be written to 497 // the tombstone file. 498 struct logger_entry* entry = &log_entry.entry_v1; 499 500 if (entry->pid != static_cast<int32_t>(pid)) { 501 // wrong pid, ignore 502 continue; 503 } 504 505 if (first) { 506 _LOG(log, 0, "--------- %slog %s\n", 507 tail ? "tail end of " : "", filename); 508 first = false; 509 } 510 511 // Msg format is: <priority:1><tag:N>\0<message:N>\0 512 // 513 // We want to display it in the same format as "logcat -v threadtime" 514 // (although in this case the pid is redundant). 515 static const char* kPrioChars = "!.VDIWEFS"; 516 unsigned hdr_size = log_entry.entry.hdr_size; 517 if (!hdr_size) { 518 hdr_size = sizeof(log_entry.entry_v1); 519 } 520 char* msg = (char *)log_entry.buf + hdr_size; 521 unsigned char prio = msg[0]; 522 char* tag = msg + 1; 523 msg = tag + strlen(tag) + 1; 524 525 // consume any trailing newlines 526 char* nl = msg + strlen(msg) - 1; 527 while (nl >= msg && *nl == '\n') { 528 *nl-- = '\0'; 529 } 530 531 char prioChar = (prio < strlen(kPrioChars) ? kPrioChars[prio] : '?'); 532 533 char timeBuf[32]; 534 time_t sec = static_cast<time_t>(entry->sec); 535 struct tm tmBuf; 536 struct tm* ptm; 537 ptm = localtime_r(&sec, &tmBuf); 538 strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm); 539 540 // Look for line breaks ('\n') and display each text line 541 // on a separate line, prefixed with the header, like logcat does. 542 do { 543 nl = strchr(msg, '\n'); 544 if (nl) { 545 *nl = '\0'; 546 ++nl; 547 } 548 549 _LOG(log, 0, "%s.%03d %5d %5d %c %-8s: %s\n", 550 timeBuf, entry->nsec / 1000000, entry->pid, entry->tid, 551 prioChar, tag, msg); 552 553 } while ((msg = nl)); 554 } 555 556 android_logger_list_free(logger_list); 557} 558 559// Dumps the logs generated by the specified pid to the tombstone, from both 560// "system" and "main" log devices. Ideally we'd interleave the output. 561static void dump_logs(log_t* log, pid_t pid, unsigned tail) { 562 dump_log_file(log, pid, "system", tail); 563 dump_log_file(log, pid, "main", tail); 564} 565 566static void dump_abort_message(Backtrace* backtrace, log_t* log, uintptr_t address) { 567 if (address == 0) { 568 return; 569 } 570 571 address += sizeof(size_t); // Skip the buffer length. 572 573 char msg[512]; 574 memset(msg, 0, sizeof(msg)); 575 char* p = &msg[0]; 576 while (p < &msg[sizeof(msg)]) { 577 uint32_t data; 578 if (!backtrace->ReadWord(address, &data)) { 579 break; 580 } 581 address += sizeof(uint32_t); 582 583 if ((*p++ = (data >> 0) & 0xff) == 0) { 584 break; 585 } 586 if ((*p++ = (data >> 8) & 0xff) == 0) { 587 break; 588 } 589 if ((*p++ = (data >> 16) & 0xff) == 0) { 590 break; 591 } 592 if ((*p++ = (data >> 24) & 0xff) == 0) { 593 break; 594 } 595 } 596 msg[sizeof(msg) - 1] = '\0'; 597 598 _LOG(log, SCOPE_AT_FAULT, "Abort message: '%s'\n", msg); 599} 600 601// Dumps all information about the specified pid to the tombstone. 602static bool dump_crash(log_t* log, pid_t pid, pid_t tid, int signal, uintptr_t abort_msg_address, 603 bool dump_sibling_threads, int* total_sleep_time_usec) { 604 // don't copy log messages to tombstone unless this is a dev device 605 char value[PROPERTY_VALUE_MAX]; 606 property_get("ro.debuggable", value, "0"); 607 bool want_logs = (value[0] == '1'); 608 609 if (log->amfd >= 0) { 610 // Activity Manager protocol: binary 32-bit network-byte-order ints for the 611 // pid and signal number, followed by the raw text of the dump, culminating 612 // in a zero byte that marks end-of-data. 613 uint32_t datum = htonl(pid); 614 TEMP_FAILURE_RETRY( write(log->amfd, &datum, 4) ); 615 datum = htonl(signal); 616 TEMP_FAILURE_RETRY( write(log->amfd, &datum, 4) ); 617 } 618 619 _LOG(log, SCOPE_AT_FAULT, 620 "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n"); 621 dump_build_info(log); 622 dump_revision_info(log); 623 dump_thread_info(log, pid, tid, SCOPE_AT_FAULT); 624 if (signal) { 625 dump_fault_addr(log, tid, signal); 626 } 627 628 UniquePtr<BacktraceMap> map(BacktraceMap::Create(pid)); 629 UniquePtr<Backtrace> backtrace(Backtrace::Create(pid, tid, map.get())); 630 if (backtrace->Unwind(0)) { 631 dump_abort_message(backtrace.get(), log, abort_msg_address); 632 dump_thread(backtrace.get(), log, SCOPE_AT_FAULT, total_sleep_time_usec); 633 } 634 635 if (want_logs) { 636 dump_logs(log, pid, 5); 637 } 638 639 bool detach_failed = false; 640 if (dump_sibling_threads) { 641 detach_failed = dump_sibling_thread_report(log, pid, tid, total_sleep_time_usec, map.get()); 642 } 643 644 if (want_logs) { 645 dump_logs(log, pid, 0); 646 } 647 648 // send EOD to the Activity Manager, then wait for its ack to avoid racing ahead 649 // and killing the target out from under it 650 if (log->amfd >= 0) { 651 uint8_t eodMarker = 0; 652 TEMP_FAILURE_RETRY( write(log->amfd, &eodMarker, 1) ); 653 // 3 sec timeout reading the ack; we're fine if that happens 654 TEMP_FAILURE_RETRY( read(log->amfd, &eodMarker, 1) ); 655 } 656 657 return detach_failed; 658} 659 660// find_and_open_tombstone - find an available tombstone slot, if any, of the 661// form tombstone_XX where XX is 00 to MAX_TOMBSTONES-1, inclusive. If no 662// file is available, we reuse the least-recently-modified file. 663// 664// Returns the path of the tombstone file, allocated using malloc(). Caller must free() it. 665static char* find_and_open_tombstone(int* fd) { 666 unsigned long mtime = ULONG_MAX; 667 struct stat sb; 668 669 // XXX: Our stat.st_mtime isn't time_t. If it changes, as it probably ought 670 // to, our logic breaks. This check will generate a warning if that happens. 671 typecheck(mtime, sb.st_mtime); 672 673 // In a single wolf-like pass, find an available slot and, in case none 674 // exist, find and record the least-recently-modified file. 675 char path[128]; 676 int oldest = 0; 677 for (int i = 0; i < MAX_TOMBSTONES; i++) { 678 snprintf(path, sizeof(path), TOMBSTONE_DIR"/tombstone_%02d", i); 679 680 if (!stat(path, &sb)) { 681 if (sb.st_mtime < mtime) { 682 oldest = i; 683 mtime = sb.st_mtime; 684 } 685 continue; 686 } 687 if (errno != ENOENT) 688 continue; 689 690 *fd = open(path, O_CREAT | O_EXCL | O_WRONLY, 0600); 691 if (*fd < 0) 692 continue; // raced ? 693 694 fchown(*fd, AID_SYSTEM, AID_SYSTEM); 695 return strdup(path); 696 } 697 698 // we didn't find an available file, so we clobber the oldest one 699 snprintf(path, sizeof(path), TOMBSTONE_DIR"/tombstone_%02d", oldest); 700 *fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600); 701 if (*fd < 0) { 702 LOG("failed to open tombstone file '%s': %s\n", path, strerror(errno)); 703 return NULL; 704 } 705 fchown(*fd, AID_SYSTEM, AID_SYSTEM); 706 return strdup(path); 707} 708 709static int activity_manager_connect() { 710 int amfd = socket(PF_UNIX, SOCK_STREAM, 0); 711 if (amfd >= 0) { 712 struct sockaddr_un address; 713 int err; 714 715 memset(&address, 0, sizeof(address)); 716 address.sun_family = AF_UNIX; 717 strncpy(address.sun_path, NCRASH_SOCKET_PATH, sizeof(address.sun_path)); 718 err = TEMP_FAILURE_RETRY(connect( 719 amfd, reinterpret_cast<struct sockaddr*>(&address), sizeof(address))); 720 if (!err) { 721 struct timeval tv; 722 memset(&tv, 0, sizeof(tv)); 723 tv.tv_sec = 1; // tight leash 724 err = setsockopt(amfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); 725 if (!err) { 726 tv.tv_sec = 3; // 3 seconds on handshake read 727 err = setsockopt(amfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); 728 } 729 } 730 if (err) { 731 close(amfd); 732 amfd = -1; 733 } 734 } 735 736 return amfd; 737} 738 739char* engrave_tombstone( 740 pid_t pid, pid_t tid, int signal, uintptr_t abort_msg_address, bool dump_sibling_threads, 741 bool quiet, bool* detach_failed, int* total_sleep_time_usec) { 742 mkdir(TOMBSTONE_DIR, 0755); 743 chown(TOMBSTONE_DIR, AID_SYSTEM, AID_SYSTEM); 744 745 int fd = -1; 746 char* path = NULL; 747 if (selinux_android_restorecon(TOMBSTONE_DIR) == 0) { 748 path = find_and_open_tombstone(&fd); 749 } else { 750 LOG("Failed to restore security context, not writing tombstone.\n"); 751 } 752 753 if (fd < 0 && quiet) { 754 LOG("Skipping tombstone write, nothing to do.\n"); 755 *detach_failed = false; 756 return NULL; 757 } 758 759 log_t log; 760 log.tfd = fd; 761 // Preserve amfd since it can be modified through the calls below without 762 // being closed. 763 int amfd = activity_manager_connect(); 764 log.amfd = amfd; 765 log.quiet = quiet; 766 *detach_failed = dump_crash( 767 &log, pid, tid, signal, abort_msg_address, dump_sibling_threads, total_sleep_time_usec); 768 769 // Either of these file descriptors can be -1, any error is ignored. 770 close(amfd); 771 close(fd); 772 773 return path; 774} 775