Enhance native stack dumps.
Provides a new mechanism for dumpstate (while running as root)
to request that debuggerd dump the stacks of native processes that
we care about in bug reports. In this mode, the backtrace
is formatted to look similar to a Dalvik backtrace.
Moved the tombstone generating code into a separate file to
make it easier to maintain.
Fixed a bug where sometimes the stack traces would be incomplete
because we were not waiting for each thread to stop after issuing
PTRACE_ATTACH, only the main thread. So sometimes we were missing
traces for some threads.
Refactored the logging code to prevent accidentally writing data
to logcat when explicitly dumping a tombstone or backtrace from the
console.
Only root or system server can request to dump backtraces but
only root can dump tombstones.
Bug: 6615693
Change-Id: Ib3edcc16f9f3a687e414e3f2d250d9500566123b
diff --git a/debuggerd/debuggerd.c b/debuggerd/debuggerd.c
index 662683a..8009631 100644
--- a/debuggerd/debuggerd.c
+++ b/debuggerd/debuggerd.c
@@ -23,6 +23,7 @@
#include <fcntl.h>
#include <sys/types.h>
#include <dirent.h>
+#include <time.h>
#include <sys/ptrace.h>
#include <sys/wait.h>
@@ -34,6 +35,7 @@
#include <cutils/logd.h>
#include <cutils/logger.h>
#include <cutils/properties.h>
+#include <cutils/debugger.h>
#include <corkscrew/backtrace.h>
@@ -41,432 +43,16 @@
#include <private/android_filesystem_config.h>
+#include "backtrace.h"
#include "getevent.h"
-#include "machine.h"
+#include "tombstone.h"
#include "utility.h"
-#define ANDROID_LOG_INFO 4
-
-static void dump_build_info(int tfd)
-{
- char fingerprint[PROPERTY_VALUE_MAX];
-
- property_get("ro.build.fingerprint", fingerprint, "unknown");
-
- _LOG(tfd, false, "Build fingerprint: '%s'\n", fingerprint);
-}
-
-static const char *get_signame(int sig)
-{
- switch(sig) {
- case SIGILL: return "SIGILL";
- case SIGABRT: return "SIGABRT";
- case SIGBUS: return "SIGBUS";
- case SIGFPE: return "SIGFPE";
- case SIGSEGV: return "SIGSEGV";
- case SIGPIPE: return "SIGPIPE";
- case SIGSTKFLT: return "SIGSTKFLT";
- case SIGSTOP: return "SIGSTOP";
- default: return "?";
- }
-}
-
-static const char *get_sigcode(int signo, int code)
-{
- switch (signo) {
- case SIGILL:
- switch (code) {
- case ILL_ILLOPC: return "ILL_ILLOPC";
- case ILL_ILLOPN: return "ILL_ILLOPN";
- case ILL_ILLADR: return "ILL_ILLADR";
- case ILL_ILLTRP: return "ILL_ILLTRP";
- case ILL_PRVOPC: return "ILL_PRVOPC";
- case ILL_PRVREG: return "ILL_PRVREG";
- case ILL_COPROC: return "ILL_COPROC";
- case ILL_BADSTK: return "ILL_BADSTK";
- }
- break;
- case SIGBUS:
- switch (code) {
- case BUS_ADRALN: return "BUS_ADRALN";
- case BUS_ADRERR: return "BUS_ADRERR";
- case BUS_OBJERR: return "BUS_OBJERR";
- }
- break;
- case SIGFPE:
- switch (code) {
- case FPE_INTDIV: return "FPE_INTDIV";
- case FPE_INTOVF: return "FPE_INTOVF";
- case FPE_FLTDIV: return "FPE_FLTDIV";
- case FPE_FLTOVF: return "FPE_FLTOVF";
- case FPE_FLTUND: return "FPE_FLTUND";
- case FPE_FLTRES: return "FPE_FLTRES";
- case FPE_FLTINV: return "FPE_FLTINV";
- case FPE_FLTSUB: return "FPE_FLTSUB";
- }
- break;
- case SIGSEGV:
- switch (code) {
- case SEGV_MAPERR: return "SEGV_MAPERR";
- case SEGV_ACCERR: return "SEGV_ACCERR";
- }
- break;
- }
- return "?";
-}
-
-static void dump_fault_addr(int tfd, pid_t tid, int sig)
-{
- siginfo_t si;
-
- memset(&si, 0, sizeof(si));
- if(ptrace(PTRACE_GETSIGINFO, tid, 0, &si)){
- _LOG(tfd, false, "cannot get siginfo: %s\n", strerror(errno));
- } else if (signal_has_address(sig)) {
- _LOG(tfd, false, "signal %d (%s), code %d (%s), fault addr %08x\n",
- sig, get_signame(sig),
- si.si_code, get_sigcode(sig, si.si_code),
- (uintptr_t) si.si_addr);
- } else {
- _LOG(tfd, false, "signal %d (%s), code %d (%s), fault addr --------\n",
- sig, get_signame(sig), si.si_code, get_sigcode(sig, si.si_code));
- }
-}
-
-static void dump_crash_banner(int tfd, pid_t pid, pid_t tid, int sig)
-{
- char data[1024];
- char *x = 0;
- FILE *fp;
-
- sprintf(data, "/proc/%d/cmdline", pid);
- fp = fopen(data, "r");
- if(fp) {
- x = fgets(data, 1024, fp);
- fclose(fp);
- }
-
- _LOG(tfd, false,
- "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
- dump_build_info(tfd);
- _LOG(tfd, false, "pid: %d, tid: %d >>> %s <<<\n",
- pid, tid, x ? x : "UNKNOWN");
-
- if(sig) {
- dump_fault_addr(tfd, tid, sig);
- }
-}
-
-/* Return true if some thread is not detached cleanly */
-static bool dump_sibling_thread_report(const ptrace_context_t* context,
- int tfd, pid_t pid, pid_t tid) {
- char task_path[64];
- snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
-
- DIR* d = opendir(task_path);
- /* Bail early if cannot open the task directory */
- if (d == NULL) {
- XLOG("Cannot open /proc/%d/task\n", pid);
- return false;
- }
-
- bool detach_failed = false;
- struct dirent *de;
- while ((de = readdir(d)) != NULL) {
- pid_t new_tid;
- /* Ignore "." and ".." */
- if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
- continue;
- }
-
- new_tid = atoi(de->d_name);
- /* The main thread at fault has been handled individually */
- if (new_tid == tid) {
- continue;
- }
-
- /* Skip this thread if cannot ptrace it */
- if (ptrace(PTRACE_ATTACH, new_tid, 0, 0) < 0) {
- continue;
- }
-
- _LOG(tfd, true, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
- _LOG(tfd, true, "pid: %d, tid: %d\n", pid, new_tid);
-
- dump_thread(context, tfd, new_tid, false);
-
- if (ptrace(PTRACE_DETACH, new_tid, 0, 0) != 0) {
- LOG("ptrace detach from %d failed: %s\n", new_tid, strerror(errno));
- detach_failed = true;
- }
- }
-
- closedir(d);
- return detach_failed;
-}
-
-/*
- * Reads the contents of the specified log device, filters out the entries
- * that don't match the specified pid, and writes them to the tombstone file.
- *
- * If "tailOnly" is set, we only print the last few lines.
- */
-static void dump_log_file(int tfd, pid_t pid, const char* filename,
- bool tailOnly)
-{
- bool first = true;
-
- /* circular buffer, for "tailOnly" mode */
- const int kShortLogMaxLines = 5;
- const int kShortLogLineLen = 256;
- char shortLog[kShortLogMaxLines][kShortLogLineLen];
- int shortLogCount = 0;
- int shortLogNext = 0;
-
- int logfd = open(filename, O_RDONLY | O_NONBLOCK);
- if (logfd < 0) {
- XLOG("Unable to open %s: %s\n", filename, strerror(errno));
- return;
- }
-
- union {
- unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];
- struct logger_entry entry;
- } log_entry;
-
- while (true) {
- ssize_t actual = read(logfd, log_entry.buf, LOGGER_ENTRY_MAX_LEN);
- if (actual < 0) {
- if (errno == EINTR) {
- /* interrupted by signal, retry */
- continue;
- } else if (errno == EAGAIN) {
- /* non-blocking EOF; we're done */
- break;
- } else {
- _LOG(tfd, true, "Error while reading log: %s\n",
- strerror(errno));
- break;
- }
- } else if (actual == 0) {
- _LOG(tfd, true, "Got zero bytes while reading log: %s\n",
- strerror(errno));
- break;
- }
-
- /*
- * NOTE: if you XLOG something here, this will spin forever,
- * because you will be writing as fast as you're reading. Any
- * high-frequency debug diagnostics should just be written to
- * the tombstone file.
- */
-
- struct logger_entry* entry = &log_entry.entry;
-
- if (entry->pid != (int32_t) pid) {
- /* wrong pid, ignore */
- continue;
- }
-
- if (first) {
- _LOG(tfd, true, "--------- %slog %s\n",
- tailOnly ? "tail end of " : "", filename);
- first = false;
- }
-
- /*
- * Msg format is: <priority:1><tag:N>\0<message:N>\0
- *
- * We want to display it in the same format as "logcat -v threadtime"
- * (although in this case the pid is redundant).
- *
- * TODO: scan for line breaks ('\n') and display each text line
- * on a separate line, prefixed with the header, like logcat does.
- */
- static const char* kPrioChars = "!.VDIWEFS";
- unsigned char prio = entry->msg[0];
- char* tag = entry->msg + 1;
- char* msg = tag + strlen(tag) + 1;
-
- /* consume any trailing newlines */
- char* eatnl = msg + strlen(msg) - 1;
- while (eatnl >= msg && *eatnl == '\n') {
- *eatnl-- = '\0';
- }
-
- char prioChar = (prio < strlen(kPrioChars) ? kPrioChars[prio] : '?');
-
- char timeBuf[32];
- time_t sec = (time_t) entry->sec;
- struct tm tmBuf;
- struct tm* ptm;
- ptm = localtime_r(&sec, &tmBuf);
- strftime(timeBuf, sizeof(timeBuf), "%m-%d %H:%M:%S", ptm);
-
- if (tailOnly) {
- snprintf(shortLog[shortLogNext], kShortLogLineLen,
- "%s.%03d %5d %5d %c %-8s: %s",
- timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
- prioChar, tag, msg);
- shortLogNext = (shortLogNext + 1) % kShortLogMaxLines;
- shortLogCount++;
- } else {
- _LOG(tfd, true, "%s.%03d %5d %5d %c %-8s: %s\n",
- timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
- prioChar, tag, msg);
- }
- }
-
- if (tailOnly) {
- int i;
-
- /*
- * If we filled the buffer, we want to start at "next", which has
- * the oldest entry. If we didn't, we want to start at zero.
- */
- if (shortLogCount < kShortLogMaxLines) {
- shortLogNext = 0;
- } else {
- shortLogCount = kShortLogMaxLines; /* cap at window size */
- }
-
- for (i = 0; i < shortLogCount; i++) {
- _LOG(tfd, true, "%s\n", shortLog[shortLogNext]);
- shortLogNext = (shortLogNext + 1) % kShortLogMaxLines;
- }
- }
-
- close(logfd);
-}
-
-/*
- * Dumps the logs generated by the specified pid to the tombstone, from both
- * "system" and "main" log devices. Ideally we'd interleave the output.
- */
-static void dump_logs(int tfd, pid_t pid, bool tailOnly)
-{
- dump_log_file(tfd, pid, "/dev/log/system", tailOnly);
- dump_log_file(tfd, pid, "/dev/log/main", tailOnly);
-}
-
-/*
- * Dumps all information about the specified pid to the tombstone.
- */
-static bool dump_crash(int tfd, pid_t pid, pid_t tid, int signal,
- bool dump_sibling_threads)
-{
- /* don't copy log messages to tombstone unless this is a dev device */
- char value[PROPERTY_VALUE_MAX];
- property_get("ro.debuggable", value, "0");
- bool wantLogs = (value[0] == '1');
-
- dump_crash_banner(tfd, pid, tid, signal);
-
- ptrace_context_t* context = load_ptrace_context(tid);
-
- dump_thread(context, tfd, tid, true);
-
- if (wantLogs) {
- dump_logs(tfd, pid, true);
- }
-
- bool detach_failed = false;
- if (dump_sibling_threads) {
- detach_failed = dump_sibling_thread_report(context, tfd, pid, tid);
- }
-
- free_ptrace_context(context);
-
- if (wantLogs) {
- dump_logs(tfd, pid, false);
- }
- return detach_failed;
-}
-
-#define MAX_TOMBSTONES 10
-
-#define typecheck(x,y) { \
- typeof(x) __dummy1; \
- typeof(y) __dummy2; \
- (void)(&__dummy1 == &__dummy2); }
-
-#define TOMBSTONE_DIR "/data/tombstones"
-
-/*
- * find_and_open_tombstone - find an available tombstone slot, if any, of the
- * form tombstone_XX where XX is 00 to MAX_TOMBSTONES-1, inclusive. If no
- * file is available, we reuse the least-recently-modified file.
- *
- * Returns the path of the tombstone file, allocated using malloc(). Caller must free() it.
- */
-static char* find_and_open_tombstone(int* fd)
-{
- unsigned long mtime = ULONG_MAX;
- struct stat sb;
-
- /*
- * XXX: Our stat.st_mtime isn't time_t. If it changes, as it probably ought
- * to, our logic breaks. This check will generate a warning if that happens.
- */
- typecheck(mtime, sb.st_mtime);
-
- /*
- * In a single wolf-like pass, find an available slot and, in case none
- * exist, find and record the least-recently-modified file.
- */
- char path[128];
- int oldest = 0;
- for (int i = 0; i < MAX_TOMBSTONES; i++) {
- snprintf(path, sizeof(path), TOMBSTONE_DIR"/tombstone_%02d", i);
-
- if (!stat(path, &sb)) {
- if (sb.st_mtime < mtime) {
- oldest = i;
- mtime = sb.st_mtime;
- }
- continue;
- }
- if (errno != ENOENT)
- continue;
-
- *fd = open(path, O_CREAT | O_EXCL | O_WRONLY, 0600);
- if (*fd < 0)
- continue; /* raced ? */
-
- fchown(*fd, AID_SYSTEM, AID_SYSTEM);
- return strdup(path);
- }
-
- /* we didn't find an available file, so we clobber the oldest one */
- snprintf(path, sizeof(path), TOMBSTONE_DIR"/tombstone_%02d", oldest);
- *fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
- if (*fd < 0) {
- LOG("failed to open tombstone file '%s': %s\n", path, strerror(errno));
- return NULL;
- }
- fchown(*fd, AID_SYSTEM, AID_SYSTEM);
- return strdup(path);
-}
-
-/* Return true if some thread is not detached cleanly */
-static char* engrave_tombstone(pid_t pid, pid_t tid, int signal, bool dump_sibling_threads,
- bool* detach_failed)
-{
- mkdir(TOMBSTONE_DIR, 0755);
- chown(TOMBSTONE_DIR, AID_SYSTEM, AID_SYSTEM);
-
- int fd;
- char* path = find_and_open_tombstone(&fd);
- if (!path) {
- *detach_failed = false;
- return NULL;
- }
-
- *detach_failed = dump_crash(fd, pid, tid, signal, dump_sibling_threads);
-
- close(fd);
- return path;
-}
+typedef struct {
+ debugger_action_t action;
+ pid_t pid, tid;
+ uid_t uid, gid;
+} debugger_request_t;
static int
write_string(const char* file, const char* string)
@@ -598,50 +184,7 @@
return fields == 7 ? 0 : -1;
}
-static int wait_for_signal(pid_t tid, int* total_sleep_time_usec) {
- const int sleep_time_usec = 200000; /* 0.2 seconds */
- const int max_total_sleep_usec = 3000000; /* 3 seconds */
- for (;;) {
- int status;
- pid_t n = waitpid(tid, &status, __WALL | WNOHANG);
- if (n < 0) {
- if(errno == EAGAIN) continue;
- LOG("waitpid failed: %s\n", strerror(errno));
- return -1;
- } else if (n > 0) {
- XLOG("waitpid: n=%d status=%08x\n", n, status);
- if (WIFSTOPPED(status)) {
- return WSTOPSIG(status);
- } else {
- LOG("unexpected waitpid response: n=%d, status=%08x\n", n, status);
- return -1;
- }
- }
-
- if (*total_sleep_time_usec > max_total_sleep_usec) {
- LOG("timed out waiting for tid=%d to die\n", tid);
- return -1;
- }
-
- /* not ready yet */
- XLOG("not ready yet\n");
- usleep(sleep_time_usec);
- *total_sleep_time_usec += sleep_time_usec;
- }
-}
-
-enum {
- REQUEST_TYPE_CRASH,
- REQUEST_TYPE_DUMP,
-};
-
-typedef struct {
- int type;
- pid_t pid, tid;
- uid_t uid, gid;
-} request_t;
-
-static int read_request(int fd, request_t* out_request) {
+static int read_request(int fd, debugger_request_t* out_request) {
struct ucred cr;
int len = sizeof(cr);
int status = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
@@ -663,20 +206,37 @@
return -1;
}
- status = TEMP_FAILURE_RETRY(read(fd, &out_request->tid, sizeof(pid_t)));
+ debugger_msg_t msg;
+ status = TEMP_FAILURE_RETRY(read(fd, &msg, sizeof(msg)));
if (status < 0) {
LOG("read failure? %s\n", strerror(errno));
return -1;
}
- if (status != sizeof(pid_t)) {
+ if (status != sizeof(msg)) {
LOG("invalid crash request of size %d\n", status);
return -1;
}
- if (out_request->tid < 0 && cr.uid == 0) {
- /* Root can ask us to attach to any process and dump it explicitly. */
- out_request->type = REQUEST_TYPE_DUMP;
- out_request->tid = -out_request->tid;
+ out_request->action = msg.action;
+ out_request->tid = msg.tid;
+ out_request->pid = cr.pid;
+ out_request->uid = cr.uid;
+ out_request->gid = cr.gid;
+
+ if (msg.action == DEBUGGER_ACTION_CRASH) {
+ /* Ensure that the tid reported by the crashing process is valid. */
+ char buf[64];
+ struct stat s;
+ snprintf(buf, sizeof buf, "/proc/%d/task/%d", out_request->pid, out_request->tid);
+ if(stat(buf, &s)) {
+ LOG("tid %d does not exist in pid %d. ignoring debug request\n",
+ out_request->tid, out_request->pid);
+ return -1;
+ }
+ } else if (cr.uid == 0
+ || (cr.uid == AID_SYSTEM && msg.action == DEBUGGER_ACTION_DUMP_BACKTRACE)) {
+ /* Only root or system can ask us to attach to any process and dump it explicitly.
+ * However, system is only allowed to collect backtraces but cannot dump tombstones. */
status = get_process_info(out_request->tid, &out_request->pid,
&out_request->uid, &out_request->gid);
if (status < 0) {
@@ -684,28 +244,15 @@
out_request->tid);
return -1;
}
- return 0;
- }
-
- /* Ensure that the tid reported by the crashing process is valid. */
- out_request->type = REQUEST_TYPE_CRASH;
- out_request->pid = cr.pid;
- out_request->uid = cr.uid;
- out_request->gid = cr.gid;
-
- char buf[64];
- struct stat s;
- snprintf(buf, sizeof buf, "/proc/%d/task/%d", out_request->pid, out_request->tid);
- if(stat(buf, &s)) {
- LOG("tid %d does not exist in pid %d. ignoring debug request\n",
- out_request->tid, out_request->pid);
+ } else {
+ /* No one else is not allowed to dump arbitrary processes. */
return -1;
}
return 0;
}
-static bool should_attach_gdb(request_t* request) {
- if (request->type == REQUEST_TYPE_CRASH) {
+static bool should_attach_gdb(debugger_request_t* request) {
+ if (request->action == DEBUGGER_ACTION_CRASH) {
char value[PROPERTY_VALUE_MAX];
property_get("debug.db.uid", value, "-1");
int debug_uid = atoi(value);
@@ -717,7 +264,7 @@
static void handle_request(int fd) {
XLOG("handle_request(%d)\n", fd);
- request_t request;
+ debugger_request_t request;
int status = read_request(fd, &request);
if (!status) {
XLOG("BOOM: pid=%d uid=%d gid=%d tid=%d\n",
@@ -739,13 +286,12 @@
} else {
bool detach_failed = false;
bool attach_gdb = should_attach_gdb(&request);
- char response = 0;
- if (TEMP_FAILURE_RETRY(write(fd, &response, 1)) != 1) {
+ if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) {
LOG("failed responding to client: %s\n", strerror(errno));
} else {
char* tombstone_path = NULL;
- if (request.type != REQUEST_TYPE_DUMP) {
+ if (request.action == DEBUGGER_ACTION_CRASH) {
close(fd);
fd = -1;
}
@@ -759,10 +305,15 @@
switch (signal) {
case SIGSTOP:
- if (request.type == REQUEST_TYPE_DUMP) {
- XLOG("stopped -- dumping\n");
+ if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
+ XLOG("stopped -- dumping to tombstone\n");
tombstone_path = engrave_tombstone(request.pid, request.tid,
- signal, true, &detach_failed);
+ signal, true, true, &detach_failed,
+ &total_sleep_time_usec);
+ } else if (request.action == DEBUGGER_ACTION_DUMP_BACKTRACE) {
+ XLOG("stopped -- dumping to fd\n");
+ dump_backtrace(fd, request.pid, request.tid, &detach_failed,
+ &total_sleep_time_usec);
} else {
XLOG("stopped -- continuing\n");
status = ptrace(PTRACE_CONT, request.tid, 0, 0);
@@ -791,7 +342,8 @@
/* don't dump sibling threads when attaching to GDB because it
* makes the process less reliable, apparently... */
tombstone_path = engrave_tombstone(request.pid, request.tid,
- signal, !attach_gdb, &detach_failed);
+ signal, !attach_gdb, false, &detach_failed,
+ &total_sleep_time_usec);
break;
}
@@ -803,7 +355,7 @@
break;
}
- if (request.type == REQUEST_TYPE_DUMP) {
+ if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
if (tombstone_path) {
write(fd, tombstone_path, strlen(tombstone_path));
}
@@ -888,7 +440,7 @@
act.sa_flags = SA_NOCLDWAIT;
sigaction(SIGCHLD, &act, 0);
- s = socket_local_server("android:debuggerd",
+ s = socket_local_server(DEBUGGER_SOCKET_NAME,
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
if(s < 0) return 1;
fcntl(s, F_SETFD, FD_CLOEXEC);
@@ -915,47 +467,56 @@
return 0;
}
-static int do_explicit_dump(pid_t tid) {
+static int do_explicit_dump(pid_t tid, bool dump_backtrace) {
fprintf(stdout, "Sending request to dump task %d.\n", tid);
- int fd = socket_local_client("android:debuggerd",
- ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
- if (fd < 0) {
- fputs("Error opening local socket to debuggerd.\n", stderr);
- return 1;
- }
-
- pid_t request = -tid;
- write(fd, &request, sizeof(pid_t));
- if (read(fd, &request, 1) != 1) {
- /* did not get expected reply, debuggerd must have closed the socket */
- fputs("Error sending request. Did not receive reply from debuggerd.\n", stderr);
+ if (dump_backtrace) {
+ fflush(stdout);
+ if (dump_backtrace_to_file(tid, fileno(stdout)) < 0) {
+ fputs("Error dumping backtrace.\n", stderr);
+ return 1;
+ }
} else {
char tombstone_path[PATH_MAX];
- ssize_t n = read(fd, &tombstone_path, sizeof(tombstone_path) - 1);
- if (n <= 0) {
- fputs("Error dumping process. Check log for details.\n", stderr);
- } else {
- tombstone_path[n] = '\0';
- fprintf(stderr, "Tombstone written to: %s\n", tombstone_path);
+ if (dump_tombstone(tid, tombstone_path, sizeof(tombstone_path)) < 0) {
+ fputs("Error dumping tombstone.\n", stderr);
+ return 1;
}
+ fprintf(stderr, "Tombstone written to: %s\n", tombstone_path);
}
-
- close(fd);
return 0;
}
+static void usage() {
+ fputs("Usage: -b [<tid>]\n"
+ " -b dump backtrace to console, otherwise dump full tombstone file\n"
+ "\n"
+ "If tid specified, sends a request to debuggerd to dump that task.\n"
+ "Otherwise, starts the debuggerd server.\n", stderr);
+}
+
int main(int argc, char** argv) {
- if (argc == 2) {
- pid_t tid = atoi(argv[1]);
- if (!tid) {
- fputs("Usage: [<tid>]\n"
- "\n"
- "If tid specified, sends a request to debuggerd to dump that task.\n"
- "Otherwise, starts the debuggerd server.\n", stderr);
+ if (argc == 1) {
+ return do_server();
+ }
+
+ bool dump_backtrace = false;
+ bool have_tid = false;
+ pid_t tid = 0;
+ for (int i = 1; i < argc; i++) {
+ if (!strcmp(argv[i], "-b")) {
+ dump_backtrace = true;
+ } else if (!have_tid) {
+ tid = atoi(argv[i]);
+ have_tid = true;
+ } else {
+ usage();
return 1;
}
- return do_explicit_dump(tid);
}
- return do_server();
+ if (!have_tid) {
+ usage();
+ return 1;
+ }
+ return do_explicit_dump(tid, dump_backtrace);
}