debuggerd/tombstone.cpp

   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 <arpa/inet.h>
  20 #include <dirent.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <inttypes.h>
  24 #include <signal.h>
  25 #include <stddef.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <time.h>
  30 #include <sys/ptrace.h>
  31 #include <sys/socket.h>
  32 #include <sys/stat.h>
  33 #include <sys/un.h>
  34
  35 #include <memory>
  36 #include <string>
  37
  38 #include <private/android_filesystem_config.h>
  39
  40 #include <base/stringprintf.h>
  41 #include <cutils/properties.h>
  42 #include <log/log.h>
  43 #include <log/logger.h>
  44 #include <log/logprint.h>
  45
  46 #include <backtrace/Backtrace.h>
  47 #include <backtrace/BacktraceMap.h>
  48
  49 #include <selinux/android.h>
  50
  51 #include "backtrace.h"
  52 #include "elf_utils.h"
  53 #include "machine.h"
  54 #include "tombstone.h"
  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 // Must match the path defined in NativeCrashListener.java
  63 #define NCRASH_SOCKET_PATH "/data/system/ndebugsocket"
  64
  65 static bool signal_has_si_addr(int sig) {
  66   switch (sig) {
  67     case SIGBUS:
  68     case SIGFPE:
  69     case SIGILL:
  70     case SIGSEGV:
  71     case SIGTRAP:
  72       return true;
  73     default:
  74       return false;
  75   }
  76 }
  77
  78 static const char* get_signame(int sig) {
  79   switch(sig) {
  80     case SIGABRT: return "SIGABRT";
  81     case SIGBUS: return "SIGBUS";
  82     case SIGFPE: return "SIGFPE";
  83     case SIGILL: return "SIGILL";
  84     case SIGPIPE: return "SIGPIPE";
  85     case SIGSEGV: return "SIGSEGV";
  86 #if defined(SIGSTKFLT)
  87     case SIGSTKFLT: return "SIGSTKFLT";
  88 #endif
  89     case SIGSTOP: return "SIGSTOP";
  90     case SIGTRAP: return "SIGTRAP";
  91     default: return "?";
  92   }
  93 }
  94
  95 static const char* get_sigcode(int signo, int code) {
  96   // Try the signal-specific codes...
  97   switch (signo) {
  98     case SIGILL:
  99       switch (code) {
 100         case ILL_ILLOPC: return "ILL_ILLOPC";
 101         case ILL_ILLOPN: return "ILL_ILLOPN";
 102         case ILL_ILLADR: return "ILL_ILLADR";
 103         case ILL_ILLTRP: return "ILL_ILLTRP";
 104         case ILL_PRVOPC: return "ILL_PRVOPC";
 105         case ILL_PRVREG: return "ILL_PRVREG";
 106         case ILL_COPROC: return "ILL_COPROC";
 107         case ILL_BADSTK: return "ILL_BADSTK";
 108       }
 109       static_assert(NSIGILL == ILL_BADSTK, "missing ILL_* si_code");
 110       break;
 111     case SIGBUS:
 112       switch (code) {
 113         case BUS_ADRALN: return "BUS_ADRALN";
 114         case BUS_ADRERR: return "BUS_ADRERR";
 115         case BUS_OBJERR: return "BUS_OBJERR";
 116         case BUS_MCEERR_AR: return "BUS_MCEERR_AR";
 117         case BUS_MCEERR_AO: return "BUS_MCEERR_AO";
 118       }
 119       static_assert(NSIGBUS == BUS_MCEERR_AO, "missing BUS_* si_code");
 120       break;
 121     case SIGFPE:
 122       switch (code) {
 123         case FPE_INTDIV: return "FPE_INTDIV";
 124         case FPE_INTOVF: return "FPE_INTOVF";
 125         case FPE_FLTDIV: return "FPE_FLTDIV";
 126         case FPE_FLTOVF: return "FPE_FLTOVF";
 127         case FPE_FLTUND: return "FPE_FLTUND";
 128         case FPE_FLTRES: return "FPE_FLTRES";
 129         case FPE_FLTINV: return "FPE_FLTINV";
 130         case FPE_FLTSUB: return "FPE_FLTSUB";
 131       }
 132       static_assert(NSIGFPE == FPE_FLTSUB, "missing FPE_* si_code");
 133       break;
 134     case SIGSEGV:
 135       switch (code) {
 136         case SEGV_MAPERR: return "SEGV_MAPERR";
 137         case SEGV_ACCERR: return "SEGV_ACCERR";
 138       }
 139       static_assert(NSIGSEGV == SEGV_ACCERR, "missing SEGV_* si_code");
 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
 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
 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     _LOG(log, logtype::HEADER, "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
 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 = NULL;
 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 (!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 = NULL;
 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
 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
 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
 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
 332 static void dump_all_maps(Backtrace* backtrace, BacktraceMap* map, log_t* log, pid_t tid) {
 333   bool print_fault_address_marker = false;
 334   uintptr_t addr = 0;
 335   siginfo_t si;
 336   memset(&si, 0, sizeof(si));
 337   if (ptrace(PTRACE_GETSIGINFO, tid, 0, &si) != -1) {
 338     print_fault_address_marker = signal_has_si_addr(si.si_signo);
 339     addr = reinterpret_cast<uintptr_t>(si.si_addr);
 340   } else {
 341     _LOG(log, logtype::ERROR, "Cannot get siginfo for %d: %s\n", tid, strerror(errno));
 342   }
 343
 344   _LOG(log, logtype::MAPS, "\n");
 345   if (!print_fault_address_marker) {
 346     _LOG(log, logtype::MAPS, "memory map:\n");
 347   } else {
 348     _LOG(log, logtype::MAPS, "memory map: (fault address prefixed with --->)\n");
 349     if (map->begin() != map->end() && addr < map->begin()->start) {
 350       _LOG(log, logtype::MAPS, "--->Fault address falls at %s before any mapped regions\n",
 351            get_addr_string(addr).c_str());
 352       print_fault_address_marker = false;
 353     }
 354   }
 355
 356   std::string line;
 357   for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) {
 358     line = "    ";
 359     if (print_fault_address_marker) {
 360       if (addr < it->start) {
 361         _LOG(log, logtype::MAPS, "--->Fault address falls at %s between mapped regions\n",
 362              get_addr_string(addr).c_str());
 363         print_fault_address_marker = false;
 364       } else if (addr >= it->start && addr < it->end) {
 365         line = "--->";
 366         print_fault_address_marker = false;
 367       }
 368     }
 369     line += get_addr_string(it->start) + '-' + get_addr_string(it->end - 1) + ' ';
 370     if (it->flags & PROT_READ) {
 371       line += 'r';
 372     } else {
 373       line += '-';
 374     }
 375     if (it->flags & PROT_WRITE) {
 376       line += 'w';
 377     } else {
 378       line += '-';
 379     }
 380     if (it->flags & PROT_EXEC) {
 381       line += 'x';
 382     } else {
 383       line += '-';
 384     }
 385     line += android::base::StringPrintf("  %8" PRIxPTR "  %8" PRIxPTR,
 386                                         it->offset, it->end - it->start);
 387     bool space_needed = true;
 388     if (it->name.length() > 0) {
 389       space_needed = false;
 390       line += "  " + it->name;
 391       std::string build_id;
 392       if ((it->flags & PROT_READ) && elf_get_build_id(backtrace, it->start, &build_id)) {
 393         line += " (BuildId: " + build_id + ")";
 394       }
 395     }
 396     if (it->load_base != 0) {
 397       if (space_needed) {
 398         line += ' ';
 399       }
 400       line += android::base::StringPrintf(" (load base 0x%" PRIxPTR ")", it->load_base);
 401     }
 402     _LOG(log, logtype::MAPS, "%s\n", line.c_str());
 403   }
 404   if (print_fault_address_marker) {
 405     _LOG(log, logtype::MAPS, "--->Fault address falls at %s after any mapped regions\n",
 406          get_addr_string(addr).c_str());
 407   }
 408 }
 409
 410 static void dump_backtrace_and_stack(Backtrace* backtrace, log_t* log) {
 411   if (backtrace->NumFrames()) {
 412     _LOG(log, logtype::BACKTRACE, "\nbacktrace:\n");
 413     dump_backtrace_to_log(backtrace, log, "    ");
 414
 415     _LOG(log, logtype::STACK, "\nstack:\n");
 416     dump_stack(backtrace, log);
 417   }
 418 }
 419
 420 // Return true if some thread is not detached cleanly
 421 static bool dump_sibling_thread_report(
 422     log_t* log, pid_t pid, pid_t tid, int* total_sleep_time_usec, BacktraceMap* map) {
 423   char task_path[64];
 424
 425   snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
 426
 427   DIR* d = opendir(task_path);
 428   // Bail early if the task directory cannot be opened
 429   if (d == NULL) {
 430     ALOGE("Cannot open /proc/%d/task\n", pid);
 431     return false;
 432   }
 433
 434   bool detach_failed = false;
 435   struct dirent* de;
 436   while ((de = readdir(d)) != NULL) {
 437     // Ignore "." and ".."
 438     if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
 439       continue;
 440     }
 441
 442     // The main thread at fault has been handled individually
 443     char* end;
 444     pid_t new_tid = strtoul(de->d_name, &end, 10);
 445     if (*end || new_tid == tid) {
 446       continue;
 447     }
 448
 449     // Skip this thread if cannot ptrace it
 450     if (ptrace(PTRACE_ATTACH, new_tid, 0, 0) < 0) {
 451       _LOG(log, logtype::ERROR, "ptrace attach to %d failed: %s\n", new_tid, strerror(errno));
 452       continue;
 453     }
 454
 455     if (wait_for_sigstop(new_tid, total_sleep_time_usec, &detach_failed) == -1) {
 456       continue;
 457     }
 458
 459     log->current_tid = new_tid;
 460     _LOG(log, logtype::THREAD, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
 461     dump_thread_info(log, pid, new_tid);
 462
 463     dump_registers(log, new_tid);
 464     std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, new_tid, map));
 465     if (backtrace->Unwind(0)) {
 466       dump_backtrace_and_stack(backtrace.get(), log);
 467     } else {
 468       ALOGE("Unwind of sibling failed: pid = %d, tid = %d", pid, new_tid);
 469     }
 470
 471     log->current_tid = log->crashed_tid;
 472
 473     if (ptrace(PTRACE_DETACH, new_tid, 0, 0) != 0) {
 474       _LOG(log, logtype::ERROR, "ptrace detach from %d failed: %s\n", new_tid, strerror(errno));
 475       detach_failed = true;
 476     }
 477   }
 478
 479   closedir(d);
 480   return detach_failed;
 481 }
 482
 483 // Reads the contents of the specified log device, filters out the entries
 484 // that don't match the specified pid, and writes them to the tombstone file.
 485 //
 486 // If "tail" is non-zero, log the last "tail" number of lines.
 487 static EventTagMap* g_eventTagMap = NULL;
 488
 489 static void dump_log_file(
 490     log_t* log, pid_t pid, const char* filename, unsigned int tail) {
 491   bool first = true;
 492   struct logger_list* logger_list;
 493
 494   if (!log->should_retrieve_logcat) {
 495     return;
 496   }
 497
 498   logger_list = android_logger_list_open(
 499       android_name_to_log_id(filename), ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, tail, pid);
 500
 501   if (!logger_list) {
 502     ALOGE("Unable to open %s: %s\n", filename, strerror(errno));
 503     return;
 504   }
 505
 506   struct log_msg log_entry;
 507
 508   while (true) {
 509     ssize_t actual = android_logger_list_read(logger_list, &log_entry);
 510     struct logger_entry* entry;
 511
 512     if (actual < 0) {
 513       if (actual == -EINTR) {
 514         // interrupted by signal, retry
 515         continue;
 516       } else if (actual == -EAGAIN) {
 517         // non-blocking EOF; we're done
 518         break;
 519       } else {
 520         _LOG(log, logtype::ERROR, "Error while reading log: %s\n",
 521           strerror(-actual));
 522         break;
 523       }
 524     } else if (actual == 0) {
 525       _LOG(log, logtype::ERROR, "Got zero bytes while reading log: %s\n",
 526         strerror(errno));
 527       break;
 528     }
 529
 530     // NOTE: if you ALOGV something here, this will spin forever,
 531     // because you will be writing as fast as you're reading.  Any
 532     // high-frequency debug diagnostics should just be written to
 533     // the tombstone file.
 534
 535     entry = &log_entry.entry_v1;
 536
 537     if (first) {
 538       _LOG(log, logtype::LOGS, "--------- %slog %s\n",
 539         tail ? "tail end of " : "", filename);
 540       first = false;
 541     }
 542
 543     // Msg format is: <priority:1><tag:N>\0<message:N>\0
 544     //
 545     // We want to display it in the same format as "logcat -v threadtime"
 546     // (although in this case the pid is redundant).
 547     static const char* kPrioChars = "!.VDIWEFS";
 548     unsigned hdr_size = log_entry.entry.hdr_size;
 549     if (!hdr_size) {
 550       hdr_size = sizeof(log_entry.entry_v1);
 551     }
 552     char* msg = reinterpret_cast<char*>(log_entry.buf) + hdr_size;
 553
 554     char timeBuf[32];
 555     time_t sec = static_cast<time_t>(entry->sec);
 556     struct tm tmBuf;
 557     struct tm* ptm;
 558     ptm = localtime_r(&sec, &tmBuf);
 559     strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm);
 560
 561     if (log_entry.id() == LOG_ID_EVENTS) {
 562       if (!g_eventTagMap) {
 563         g_eventTagMap = android_openEventTagMap(EVENT_TAG_MAP_FILE);
 564       }
 565       AndroidLogEntry e;
 566       char buf[512];
 567       android_log_processBinaryLogBuffer(entry, &e, g_eventTagMap, buf, sizeof(buf));
 568       _LOG(log, logtype::LOGS, "%s.%03d %5d %5d %c %-8s: %s\n",
 569          timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
 570          'I', e.tag, e.message);
 571       continue;
 572     }
 573
 574     unsigned char prio = msg[0];
 575     char* tag = msg + 1;
 576     msg = tag + strlen(tag) + 1;
 577
 578     // consume any trailing newlines
 579     char* nl = msg + strlen(msg) - 1;
 580     while (nl >= msg && *nl == '\n') {
 581       *nl-- = '\0';
 582     }
 583
 584     char prioChar = (prio < strlen(kPrioChars) ? kPrioChars[prio] : '?');
 585
 586     // Look for line breaks ('\n') and display each text line
 587     // on a separate line, prefixed with the header, like logcat does.
 588     do {
 589       nl = strchr(msg, '\n');
 590       if (nl) {
 591         *nl = '\0';
 592         ++nl;
 593       }
 594
 595       _LOG(log, logtype::LOGS, "%s.%03d %5d %5d %c %-8s: %s\n",
 596          timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
 597          prioChar, tag, msg);
 598     } while ((msg = nl));
 599   }
 600
 601   android_logger_list_free(logger_list);
 602 }
 603
 604 // Dumps the logs generated by the specified pid to the tombstone, from both
 605 // "system" and "main" log devices.  Ideally we'd interleave the output.
 606 static void dump_logs(log_t* log, pid_t pid, unsigned int tail) {
 607   dump_log_file(log, pid, "system", tail);
 608   dump_log_file(log, pid, "main", tail);
 609 }
 610
 611 static void dump_abort_message(Backtrace* backtrace, log_t* log, uintptr_t address) {
 612   if (address == 0) {
 613     return;
 614   }
 615
 616   address += sizeof(size_t); // Skip the buffer length.
 617
 618   char msg[512];
 619   memset(msg, 0, sizeof(msg));
 620   char* p = &msg[0];
 621   while (p < &msg[sizeof(msg)]) {
 622     word_t data;
 623     size_t len = sizeof(word_t);
 624     if (!backtrace->ReadWord(address, &data)) {
 625       break;
 626     }
 627     address += sizeof(word_t);
 628
 629     while (len > 0 && (*p++ = (data >> (sizeof(word_t) - len) * 8) & 0xff) != 0)
 630        len--;
 631   }
 632   msg[sizeof(msg) - 1] = '\0';
 633
 634   _LOG(log, logtype::HEADER, "Abort message: '%s'\n", msg);
 635 }
 636
 637 // Dumps all information about the specified pid to the tombstone.
 638 static bool dump_crash(log_t* log, pid_t pid, pid_t tid, int signal, int si_code,
 639                        uintptr_t abort_msg_address, bool dump_sibling_threads,
 640                        int* total_sleep_time_usec) {
 641   // don't copy log messages to tombstone unless this is a dev device
 642   char value[PROPERTY_VALUE_MAX];
 643   property_get("ro.debuggable", value, "0");
 644   bool want_logs = (value[0] == '1');
 645
 646   if (log->amfd >= 0) {
 647     // Activity Manager protocol: binary 32-bit network-byte-order ints for the
 648     // pid and signal number, followed by the raw text of the dump, culminating
 649     // in a zero byte that marks end-of-data.
 650     uint32_t datum = htonl(pid);
 651     TEMP_FAILURE_RETRY( write(log->amfd, &datum, 4) );
 652     datum = htonl(signal);
 653     TEMP_FAILURE_RETRY( write(log->amfd, &datum, 4) );
 654   }
 655
 656   _LOG(log, logtype::HEADER,
 657        "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
 658   dump_header_info(log);
 659   dump_thread_info(log, pid, tid);
 660
 661   if (signal) {
 662     dump_signal_info(log, tid, signal, si_code);
 663   }
 664
 665   std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(pid));
 666   std::unique_ptr<Backtrace> backtrace(Backtrace::Create(pid, tid, map.get()));
 667   dump_abort_message(backtrace.get(), log, abort_msg_address);
 668   dump_registers(log, tid);
 669   if (backtrace->Unwind(0)) {
 670     dump_backtrace_and_stack(backtrace.get(), log);
 671   } else {
 672     ALOGE("Unwind failed: pid = %d, tid = %d", pid, tid);
 673   }
 674   dump_memory_and_code(log, backtrace.get());
 675   if (map.get() != nullptr) {
 676     dump_all_maps(backtrace.get(), map.get(), log, tid);
 677   }
 678
 679   if (want_logs) {
 680     dump_logs(log, pid, 5);
 681   }
 682
 683   bool detach_failed = false;
 684   if (dump_sibling_threads) {
 685     detach_failed = dump_sibling_thread_report(log, pid, tid, total_sleep_time_usec, map.get());
 686   }
 687
 688   if (want_logs) {
 689     dump_logs(log, pid, 0);
 690   }
 691
 692   // send EOD to the Activity Manager, then wait for its ack to avoid racing ahead
 693   // and killing the target out from under it
 694   if (log->amfd >= 0) {
 695     uint8_t eodMarker = 0;
 696     TEMP_FAILURE_RETRY( write(log->amfd, &eodMarker, 1) );
 697     // 3 sec timeout reading the ack; we're fine if that happens
 698     TEMP_FAILURE_RETRY( read(log->amfd, &eodMarker, 1) );
 699   }
 700
 701   return detach_failed;
 702 }
 703
 704 // find_and_open_tombstone - find an available tombstone slot, if any, of the
 705 // form tombstone_XX where XX is 00 to MAX_TOMBSTONES-1, inclusive. If no
 706 // file is available, we reuse the least-recently-modified file.
 707 //
 708 // Returns the path of the tombstone file, allocated using malloc().  Caller must free() it.
 709 static char* find_and_open_tombstone(int* fd) {
 710   // In a single pass, find an available slot and, in case none
 711   // exist, find and record the least-recently-modified file.
 712   char path[128];
 713   int oldest = -1;
 714   struct stat oldest_sb;
 715   for (int i = 0; i < MAX_TOMBSTONES; i++) {
 716     snprintf(path, sizeof(path), TOMBSTONE_TEMPLATE, i);
 717
 718     struct stat sb;
 719     if (!stat(path, &sb)) {
 720       if (oldest < 0 || sb.st_mtime < oldest_sb.st_mtime) {
 721         oldest = i;
 722         oldest_sb.st_mtime = sb.st_mtime;
 723       }
 724       continue;
 725     }
 726     if (errno != ENOENT)
 727       continue;
 728
 729     *fd = open(path, O_CREAT | O_EXCL | O_WRONLY | O_NOFOLLOW | O_CLOEXEC, 0600);
 730     if (*fd < 0)
 731       continue;   // raced ?
 732
 733     fchown(*fd, AID_SYSTEM, AID_SYSTEM);
 734     return strdup(path);
 735   }
 736
 737   if (oldest < 0) {
 738     ALOGE("Failed to find a valid tombstone, default to using tombstone 0.\n");
 739     oldest = 0;
 740   }
 741
 742   // we didn't find an available file, so we clobber the oldest one
 743   snprintf(path, sizeof(path), TOMBSTONE_TEMPLATE, oldest);
 744   *fd = open(path, O_CREAT | O_TRUNC | O_WRONLY | O_NOFOLLOW | O_CLOEXEC, 0600);
 745   if (*fd < 0) {
 746     ALOGE("failed to open tombstone file '%s': %s\n", path, strerror(errno));
 747     return NULL;
 748   }
 749   fchown(*fd, AID_SYSTEM, AID_SYSTEM);
 750   return strdup(path);
 751 }
 752
 753 static int activity_manager_connect() {
 754   int amfd = socket(PF_UNIX, SOCK_STREAM, 0);
 755   if (amfd >= 0) {
 756     struct sockaddr_un address;
 757     int err;
 758
 759     memset(&address, 0, sizeof(address));
 760     address.sun_family = AF_UNIX;
 761     strncpy(address.sun_path, NCRASH_SOCKET_PATH, sizeof(address.sun_path));
 762     err = TEMP_FAILURE_RETRY(connect(
 763         amfd, reinterpret_cast<struct sockaddr*>(&address), sizeof(address)));
 764     if (!err) {
 765       struct timeval tv;
 766       memset(&tv, 0, sizeof(tv));
 767       tv.tv_sec = 1;  // tight leash
 768       err = setsockopt(amfd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 769       if (!err) {
 770         tv.tv_sec = 3;  // 3 seconds on handshake read
 771         err = setsockopt(amfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 772       }
 773     }
 774     if (err) {
 775       close(amfd);
 776       amfd = -1;
 777     }
 778   }
 779
 780   return amfd;
 781 }
 782
 783 char* engrave_tombstone(pid_t pid, pid_t tid, int signal, int original_si_code,
 784                         uintptr_t abort_msg_address, bool dump_sibling_threads,
 785                         bool* detach_failed, int* total_sleep_time_usec) {
 786
 787   log_t log;
 788   log.current_tid = tid;
 789   log.crashed_tid = tid;
 790
 791   int fd = -1;
 792   char* path = find_and_open_tombstone(&fd);
 793
 794   if (fd < 0) {
 795     _LOG(&log, logtype::ERROR, "Skipping tombstone write, nothing to do.\n");
 796     *detach_failed = false;
 797     return NULL;
 798   }
 799
 800   log.tfd = fd;
 801   // Preserve amfd since it can be modified through the calls below without
 802   // being closed.
 803   int amfd = activity_manager_connect();
 804   log.amfd = amfd;
 805   *detach_failed = dump_crash(&log, pid, tid, signal, original_si_code, abort_msg_address,
 806                               dump_sibling_threads, total_sleep_time_usec);
 807
 808   _LOG(&log, logtype::BACKTRACE, "\nTombstone written to: %s\n", path);
 809
 810   // Either of these file descriptors can be -1, any error is ignored.
 811   close(amfd);
 812   close(fd);
 813
 814   return path;
 815 }