ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

am 68870199: Merge "Next phase of the move, reformat use C++ features."

Browse source 
* commit '688701990db1aef2d7dbe0ccdc4f12c2dd5f51a8':
  Next phase of the move, reformat use C++ features.
This commit is contained in:
Christopher Ferris 2014-01-13 17:24:13 -08:00 • committed by Android Git Automerger
commit 1f71e465ef
17 changed files with 1796 additions and 1909 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

257
debuggerd/arm/machine.cpp
View file

@ -1,22 +1,21 @@
/* system/debuggerd/debuggerd.c /*
** *
** Copyright 2006, The Android Open Source Project * Copyright 2006, The Android Open Source Project
** *
** Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
** You may obtain a copy of the License at * You may obtain a copy of the License at
** *
** http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
** *
** Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
** limitations under the License. * limitations under the License.
*/ */
#include <errno.h> #include <errno.h>
#include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -28,7 +27,7 @@
#include "../utility.h" #include "../utility.h"
#include "../machine.h" #include "../machine.h"
/* enable to dump memory pointed to by every register */ // enable to dump memory pointed to by every register
#define DUMP_MEMORY_FOR_ALL_REGISTERS 1 #define DUMP_MEMORY_FOR_ALL_REGISTERS 1
#ifdef WITH_VFP #ifdef WITH_VFP
@ -40,140 +39,134 @@
#endif #endif
static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, int scope_flags) { static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, int scope_flags) {
char code_buffer[64]; /* actual 8+1+((8+1)*4) + 1 == 45 */ char code_buffer[64]; // actual 8+1+((8+1)*4) + 1 == 45
char ascii_buffer[32]; /* actual 16 + 1 == 17 */ char ascii_buffer[32]; // actual 16 + 1 == 17
uintptr_t p, end; uintptr_t p, end;
p = addr & ~3; p = addr & ~3;
p -= 32; p -= 32;
if (p > addr) { if (p > addr) {
/* catch underflow */ // catch underflow
p = 0; p = 0;
} }
/* Dump more memory content for the crashing thread. */ // Dump more memory content for the crashing thread.
end = p + 256; end = p + 256;
/* catch overflow; 'end - p' has to be multiples of 16 */ // catch overflow; 'end - p' has to be multiples of 16
while (end < p) while (end < p)
end -= 16; end -= 16;
/* Dump the code around PC as: // Dump the code around PC as:
* addr contents ascii // addr contents ascii
* 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q // 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q
* 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p...... // 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p......
*/ while (p < end) {
while (p < end) { char* asc_out = ascii_buffer;
char* asc_out = ascii_buffer;
sprintf(code_buffer, "%08x ", p); sprintf(code_buffer, "%08x ", p);
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
/* // If we see (data == -1 && errno != 0), we know that the ptrace
* If we see (data == -1 && errno != 0), we know that the ptrace // call failed, probably because we're dumping memory in an
* call failed, probably because we're dumping memory in an // unmapped or inaccessible page. I don't know if there's
* unmapped or inaccessible page. I don't know if there's // value in making that explicit in the output -- it likely
* value in making that explicit in the output -- it likely // just complicates parsing and clarifies nothing for the
* just complicates parsing and clarifies nothing for the // enlightened reader.
* enlightened reader. long data = ptrace(PTRACE_PEEKTEXT, tid, reinterpret_cast<void*>(p), NULL);
*/ sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
long data = ptrace(PTRACE_PEEKTEXT, tid, (void*)p, NULL);
sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
/* Enable the following code blob to dump ASCII values */ // Enable the following code blob to dump ASCII values
#if 0 #if 0
int j; int j;
for (j = 0; j < 4; j++) { for (j = 0; j < 4; j++) {
/* // Our isprint() allows high-ASCII characters that display
* Our isprint() allows high-ASCII characters that display // differently (often badly) in different viewers, so we
* differently (often badly) in different viewers, so we // just use a simpler test.
* just use a simpler test. char val = (data >> (j*8)) & 0xff;
*/ if (val >= 0x20 && val < 0x7f) {
char val = (data >> (j*8)) & 0xff; *asc_out++ = val;
if (val >= 0x20 && val < 0x7f) { } else {
*asc_out++ = val; *asc_out++ = '.';
} else { }
*asc_out++ = '.'; }
}
}
#endif #endif
p += 4; p += 4;
}
*asc_out = '\0';
_LOG(log, scope_flags, " %s %s\n", code_buffer, ascii_buffer);
} }
*asc_out = '\0';
_LOG(log, scope_flags, " %s %s\n", code_buffer, ascii_buffer);
}
} }
/* // If configured to do so, dump memory around *all* registers
* If configured to do so, dump memory around *all* registers // for the crashing thread.
* for the crashing thread.
*/
void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) { void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
struct pt_regs regs; struct pt_regs regs;
if(ptrace(PTRACE_GETREGS, tid, 0, &regs)) { if (ptrace(PTRACE_GETREGS, tid, 0, &regs)) {
return; return;
}
if (IS_AT_FAULT(scope_flags) && DUMP_MEMORY_FOR_ALL_REGISTERS) {
static const char REG_NAMES[] = "r0r1r2r3r4r5r6r7r8r9slfpipsp";
for (int reg = 0; reg < 14; reg++) {
// this may not be a valid way to access, but it'll do for now
uintptr_t addr = regs.uregs[reg];
// Don't bother if it looks like a small int or ~= null, or if
// it's in the kernel area.
if (addr < 4096 || addr >= 0xc0000000) {
continue;
}
_LOG(log, scope_flags | SCOPE_SENSITIVE, "\nmemory near %.2s:\n", &REG_NAMES[reg * 2]);
dump_memory(log, tid, addr, scope_flags | SCOPE_SENSITIVE);
} }
}
if (IS_AT_FAULT(scope_flags) && DUMP_MEMORY_FOR_ALL_REGISTERS) { // explicitly allow upload of code dump logging
static const char REG_NAMES[] = "r0r1r2r3r4r5r6r7r8r9slfpipsp"; _LOG(log, scope_flags, "\ncode around pc:\n");
dump_memory(log, tid, static_cast<uintptr_t>(regs.ARM_pc), scope_flags);
for (int reg = 0; reg < 14; reg++) { if (regs.ARM_pc != regs.ARM_lr) {
/* this may not be a valid way to access, but it'll do for now */ _LOG(log, scope_flags, "\ncode around lr:\n");
uintptr_t addr = regs.uregs[reg]; dump_memory(log, tid, static_cast<uintptr_t>(regs.ARM_lr), scope_flags);
}
/*
* Don't bother if it looks like a small int or ~= null, or if
* it's in the kernel area.
*/
if (addr < 4096 || addr >= 0xc0000000) {
continue;
}
_LOG(log, scope_flags | SCOPE_SENSITIVE, "\nmemory near %.2s:\n", &REG_NAMES[reg * 2]);
dump_memory(log, tid, addr, scope_flags | SCOPE_SENSITIVE);
}
}
/* explicitly allow upload of code dump logging */
_LOG(log, scope_flags, "\ncode around pc:\n");
dump_memory(log, tid, (uintptr_t)regs.ARM_pc, scope_flags);
if (regs.ARM_pc != regs.ARM_lr) {
_LOG(log, scope_flags, "\ncode around lr:\n");
dump_memory(log, tid, (uintptr_t)regs.ARM_lr, scope_flags);
}
} }
void dump_registers(log_t* log, pid_t tid, int scope_flags) void dump_registers(log_t* log, pid_t tid, int scope_flags) {
{ struct pt_regs r;
struct pt_regs r; if (ptrace(PTRACE_GETREGS, tid, 0, &r)) {
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) { _LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno)); return;
return; }
}
_LOG(log, scope_flags, " r0 %08x r1 %08x r2 %08x r3 %08x\n", _LOG(log, scope_flags, " r0 %08x r1 %08x r2 %08x r3 %08x\n",
(uint32_t)r.ARM_r0, (uint32_t)r.ARM_r1, (uint32_t)r.ARM_r2, (uint32_t)r.ARM_r3); static_cast<uint32_t>(r.ARM_r0), static_cast<uint32_t>(r.ARM_r1),
_LOG(log, scope_flags, " r4 %08x r5 %08x r6 %08x r7 %08x\n", static_cast<uint32_t>(r.ARM_r2), static_cast<uint32_t>(r.ARM_r3));
(uint32_t)r.ARM_r4, (uint32_t)r.ARM_r5, (uint32_t)r.ARM_r6, (uint32_t)r.ARM_r7); _LOG(log, scope_flags, " r4 %08x r5 %08x r6 %08x r7 %08x\n",
_LOG(log, scope_flags, " r8 %08x r9 %08x sl %08x fp %08x\n", static_cast<uint32_t>(r.ARM_r4), static_cast<uint32_t>(r.ARM_r5),
(uint32_t)r.ARM_r8, (uint32_t)r.ARM_r9, (uint32_t)r.ARM_r10, (uint32_t)r.ARM_fp); static_cast<uint32_t>(r.ARM_r6), static_cast<uint32_t>(r.ARM_r7));
_LOG(log, scope_flags, " ip %08x sp %08x lr %08x pc %08x cpsr %08x\n", _LOG(log, scope_flags, " r8 %08x r9 %08x sl %08x fp %08x\n",
(uint32_t)r.ARM_ip, (uint32_t)r.ARM_sp, (uint32_t)r.ARM_lr, static_cast<uint32_t>(r.ARM_r8), static_cast<uint32_t>(r.ARM_r9),
(uint32_t)r.ARM_pc, (uint32_t)r.ARM_cpsr); static_cast<uint32_t>(r.ARM_r10), static_cast<uint32_t>(r.ARM_fp));
_LOG(log, scope_flags, " ip %08x sp %08x lr %08x pc %08x cpsr %08x\n",
static_cast<uint32_t>(r.ARM_ip), static_cast<uint32_t>(r.ARM_sp),
static_cast<uint32_t>(r.ARM_lr), static_cast<uint32_t>(r.ARM_pc),
static_cast<uint32_t>(r.ARM_cpsr));
#ifdef WITH_VFP #ifdef WITH_VFP
struct user_vfp vfp_regs; struct user_vfp vfp_regs;
int i; int i;
if(ptrace(PTRACE_GETVFPREGS, tid, 0, &vfp_regs)) { if (ptrace(PTRACE_GETVFPREGS, tid, 0, &vfp_regs)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno)); _LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return; return;
} }
for (i = 0; i < NUM_VFP_REGS; i += 2) { for (i = 0; i < NUM_VFP_REGS; i += 2) {
_LOG(log, scope_flags, " d%-2d %016llx d%-2d %016llx\n", _LOG(log, scope_flags, " d%-2d %016llx d%-2d %016llx\n",
i, vfp_regs.fpregs[i], i+1, vfp_regs.fpregs[i+1]); i, vfp_regs.fpregs[i], i+1, vfp_regs.fpregs[i+1]);
} }
_LOG(log, scope_flags, " scr %08lx\n", vfp_regs.fpscr); _LOG(log, scope_flags, " scr %08lx\n", vfp_regs.fpscr);
#endif #endif
} }

166
debuggerd/backtrace.cpp
View file

@ -15,7 +15,6 @@
*/ */
#include <stddef.h> #include <stddef.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
@ -27,121 +26,116 @@
#include <sys/types.h> #include <sys/types.h>
#include <sys/ptrace.h> #include <sys/ptrace.h>
#include <backtrace/backtrace.h> #include <backtrace/Backtrace.h>
#include <UniquePtr.h>
#include "backtrace.h" #include "backtrace.h"
#include "utility.h" #include "utility.h"
static void dump_process_header(log_t* log, pid_t pid) { static void dump_process_header(log_t* log, pid_t pid) {
char path[PATH_MAX]; char path[PATH_MAX];
char procnamebuf[1024]; char procnamebuf[1024];
char* procname = NULL; char* procname = NULL;
FILE* fp; FILE* fp;
snprintf(path, sizeof(path), "/proc/%d/cmdline", pid); snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
if ((fp = fopen(path, "r"))) { if ((fp = fopen(path, "r"))) {
procname = fgets(procnamebuf, sizeof(procnamebuf), fp); procname = fgets(procnamebuf, sizeof(procnamebuf), fp);
fclose(fp); fclose(fp);
} }
time_t t = time(NULL); time_t t = time(NULL);
struct tm tm; struct tm tm;
localtime_r(&t, &tm); localtime_r(&t, &tm);
char timestr[64]; char timestr[64];
strftime(timestr, sizeof(timestr), "%F %T", &tm); strftime(timestr, sizeof(timestr), "%F %T", &tm);
_LOG(log, SCOPE_AT_FAULT, "\n\n----- pid %d at %s -----\n", pid, timestr); _LOG(log, SCOPE_AT_FAULT, "\n\n----- pid %d at %s -----\n", pid, timestr);
if (procname) { if (procname) {
_LOG(log, SCOPE_AT_FAULT, "Cmd line: %s\n", procname); _LOG(log, SCOPE_AT_FAULT, "Cmd line: %s\n", procname);
} }
} }
static void dump_process_footer(log_t* log, pid_t pid) { static void dump_process_footer(log_t* log, pid_t pid) {
_LOG(log, SCOPE_AT_FAULT, "\n----- end %d -----\n", pid); _LOG(log, SCOPE_AT_FAULT, "\n----- end %d -----\n", pid);
} }
static void dump_thread(log_t* log, pid_t tid, bool attached, static void dump_thread(
bool* detach_failed, int* total_sleep_time_usec) { log_t* log, pid_t tid, bool attached, bool* detach_failed, int* total_sleep_time_usec) {
char path[PATH_MAX]; char path[PATH_MAX];
char threadnamebuf[1024]; char threadnamebuf[1024];
char* threadname = NULL; char* threadname = NULL;
FILE* fp; FILE* fp;
snprintf(path, sizeof(path), "/proc/%d/comm", tid); snprintf(path, sizeof(path), "/proc/%d/comm", tid);
if ((fp = fopen(path, "r"))) { if ((fp = fopen(path, "r"))) {
threadname = fgets(threadnamebuf, sizeof(threadnamebuf), fp); threadname = fgets(threadnamebuf, sizeof(threadnamebuf), fp);
fclose(fp); fclose(fp);
if (threadname) { if (threadname) {
size_t len = strlen(threadname); size_t len = strlen(threadname);
if (len && threadname[len - 1] == '\n') { if (len && threadname[len - 1] == '\n') {
threadname[len - 1] = '\0'; threadname[len - 1] = '\0';
} }
}
} }
}
_LOG(log, SCOPE_AT_FAULT, "\n\"%s\" sysTid=%d\n", _LOG(log, SCOPE_AT_FAULT, "\n\"%s\" sysTid=%d\n", threadname ? threadname : "<unknown>", tid);
threadname ? threadname : "<unknown>", tid);
if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) { if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) {
_LOG(log, SCOPE_AT_FAULT, "Could not attach to thread: %s\n", strerror(errno)); _LOG(log, SCOPE_AT_FAULT, "Could not attach to thread: %s\n", strerror(errno));
return; return;
} }
wait_for_stop(tid, total_sleep_time_usec); wait_for_stop(tid, total_sleep_time_usec);
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(tid, BACKTRACE_CURRENT_THREAD));
if (!backtrace_create_context(&context, tid, -1, 0)) { if (backtrace->Unwind(0)) {
_LOG(log, SCOPE_AT_FAULT, "Could not create backtrace context.\n"); dump_backtrace_to_log(backtrace.get(), log, SCOPE_AT_FAULT, " ");
} else { }
dump_backtrace_to_log(&context, log, SCOPE_AT_FAULT, " ");
backtrace_destroy_context(&context);
}
if (!attached && ptrace(PTRACE_DETACH, tid, 0, 0) != 0) { if (!attached && ptrace(PTRACE_DETACH, tid, 0, 0) != 0) {
LOG("ptrace detach from %d failed: %s\n", tid, strerror(errno)); LOG("ptrace detach from %d failed: %s\n", tid, strerror(errno));
*detach_failed = true; *detach_failed = true;
} }
} }
void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed, void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed,
int* total_sleep_time_usec) { int* total_sleep_time_usec) {
log_t log; log_t log;
log.tfd = fd; log.tfd = fd;
log.amfd = amfd; log.amfd = amfd;
log.quiet = true; log.quiet = true;
dump_process_header(&log, pid); dump_process_header(&log, pid);
dump_thread(&log, tid, true, detach_failed, total_sleep_time_usec); dump_thread(&log, tid, true, detach_failed, total_sleep_time_usec);
char task_path[64]; char task_path[64];
snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid); snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
DIR* d = opendir(task_path); DIR* d = opendir(task_path);
if (d != NULL) { if (d != NULL) {
struct dirent* de = NULL; struct dirent* de = NULL;
while ((de = readdir(d)) != NULL) { while ((de = readdir(d)) != NULL) {
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) { if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) {
continue; continue;
} }
char* end; char* end;
pid_t new_tid = strtoul(de->d_name, &end, 10); pid_t new_tid = strtoul(de->d_name, &end, 10);
if (*end || new_tid == tid) { if (*end || new_tid == tid) {
continue; continue;
} }
dump_thread(&log, new_tid, false, detach_failed, total_sleep_time_usec); dump_thread(&log, new_tid, false, detach_failed, total_sleep_time_usec);
}
closedir(d);
} }
closedir(d);
}
dump_process_footer(&log, pid); dump_process_footer(&log, pid);
} }
void dump_backtrace_to_log(const backtrace_context_t* context, log_t* log, void dump_backtrace_to_log(Backtrace* backtrace, log_t* log,
int scope_flags, const char* prefix) { int scope_flags, const char* prefix) {
char buf[512]; for (size_t i = 0; i < backtrace->NumFrames(); i++) {
for (size_t i = 0; i < context->backtrace->num_frames; i++) { _LOG(log, scope_flags, "%s%s\n", prefix, backtrace->FormatFrameData(i).c_str());
backtrace_format_frame_data(context, i, buf, sizeof(buf)); }
_LOG(log, scope_flags, "%s%s\n", prefix, buf);
}
} }

16
debuggerd/backtrace.h
View file

@ -17,21 +17,19 @@
#ifndef _DEBUGGERD_BACKTRACE_H #ifndef _DEBUGGERD_BACKTRACE_H
#define _DEBUGGERD_BACKTRACE_H #define _DEBUGGERD_BACKTRACE_H
#include <stddef.h>
#include <stdbool.h>
#include <sys/types.h> #include <sys/types.h>
#include <backtrace/backtrace.h>
#include "utility.h" #include "utility.h"
/* Dumps a backtrace using a format similar to what Dalvik uses so that the result class Backtrace;
* can be intermixed in a bug report. */
// Dumps a backtrace using a format similar to what Dalvik uses so that the result
// can be intermixed in a bug report.
void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed, void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed,
int* total_sleep_time_usec); int* total_sleep_time_usec);
/* Dumps the backtrace in the backtrace data structure to the log. */ /* Dumps the backtrace in the backtrace data structure to the log. */
void dump_backtrace_to_log(const backtrace_context_t* context, log_t* log, void dump_backtrace_to_log(Backtrace* backtrace, log_t* log,
int scope_flags, const char* prefix); int scope_flags, const char* prefix);
#endif // _DEBUGGERD_BACKTRACE_H #endif // _DEBUGGERD_BACKTRACE_H

861
debuggerd/debuggerd.cpp
View file

@ -1,19 +1,18 @@
/* system/debuggerd/debuggerd.c /*
** * Copyright 2006, The Android Open Source Project
** Copyright 2006, The Android Open Source Project *
** * Licensed under the Apache License, Version 2.0 (the "License");
** Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License.
** you may not use this file except in compliance with the License. * You may obtain a copy of the License at
** You may obtain a copy of the License at *
** * http://www.apache.org/licenses/LICENSE-2.0
** http://www.apache.org/licenses/LICENSE-2.0 *
** * Unless required by applicable law or agreed to in writing, software
** Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS,
** distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and
** See the License for the specific language governing permissions and * limitations under the License.
** limitations under the License. */
*/
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>
@ -38,8 +37,6 @@
#include <cutils/properties.h> #include <cutils/properties.h>
#include <cutils/debugger.h> #include <cutils/debugger.h>
#include <corkscrew/backtrace.h>
#include <linux/input.h> #include <linux/input.h>
#include <private/android_filesystem_config.h> #include <private/android_filesystem_config.h>
@ -50,490 +47,468 @@
#include "utility.h" #include "utility.h"
typedef struct { typedef struct {
debugger_action_t action; debugger_action_t action;
pid_t pid, tid; pid_t pid, tid;
uid_t uid, gid; uid_t uid, gid;
uintptr_t abort_msg_address; uintptr_t abort_msg_address;
} debugger_request_t; } debugger_request_t;
static int static int write_string(const char* file, const char* string) {
write_string(const char* file, const char* string) int len;
{ int fd;
int len; ssize_t amt;
int fd; fd = open(file, O_RDWR);
ssize_t amt; len = strlen(string);
fd = open(file, O_RDWR); if (fd < 0)
len = strlen(string); return -errno;
if (fd < 0) amt = write(fd, string, len);
return -errno; close(fd);
amt = write(fd, string, len); return amt >= 0 ? 0 : -errno;
close(fd);
return amt >= 0 ? 0 : -errno;
} }
static static void init_debug_led() {
void init_debug_led(void) // trout leds
{ write_string("/sys/class/leds/red/brightness", "0");
// trout leds write_string("/sys/class/leds/green/brightness", "0");
write_string("/sys/class/leds/red/brightness", "0"); write_string("/sys/class/leds/blue/brightness", "0");
write_string("/sys/class/leds/green/brightness", "0"); write_string("/sys/class/leds/red/device/blink", "0");
write_string("/sys/class/leds/blue/brightness", "0"); // sardine leds
write_string("/sys/class/leds/red/device/blink", "0"); write_string("/sys/class/leds/left/cadence", "0,0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "0,0");
} }
static static void enable_debug_led() {
void enable_debug_led(void) // trout leds
{ write_string("/sys/class/leds/red/brightness", "255");
// trout leds // sardine leds
write_string("/sys/class/leds/red/brightness", "255"); write_string("/sys/class/leds/left/cadence", "1,0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "1,0");
} }
static static void disable_debug_led() {
void disable_debug_led(void) // trout leds
{ write_string("/sys/class/leds/red/brightness", "0");
// trout leds // sardine leds
write_string("/sys/class/leds/red/brightness", "0"); write_string("/sys/class/leds/left/cadence", "0,0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "0,0");
} }
static void wait_for_user_action(pid_t pid) { static void wait_for_user_action(pid_t pid) {
/* First log a helpful message */ // First log a helpful message
LOG( "********************************************************\n" LOG( "********************************************************\n"
"* Process %d has been suspended while crashing. To\n" "* Process %d has been suspended while crashing. To\n"
"* attach gdbserver for a gdb connection on port 5039\n" "* attach gdbserver for a gdb connection on port 5039\n"
"* and start gdbclient:\n" "* and start gdbclient:\n"
"*\n" "*\n"
"* gdbclient app_process :5039 %d\n" "* gdbclient app_process :5039 %d\n"
"*\n" "*\n"
"* Wait for gdb to start, then press HOME or VOLUME DOWN key\n" "* Wait for gdb to start, then press HOME or VOLUME DOWN key\n"
"* to let the process continue crashing.\n" "* to let the process continue crashing.\n"
"********************************************************\n", "********************************************************\n",
pid, pid); pid, pid);
/* wait for HOME or VOLUME DOWN key */ // wait for HOME or VOLUME DOWN key
if (init_getevent() == 0) { if (init_getevent() == 0) {
int ms = 1200 / 10; int ms = 1200 / 10;
int dit = 1; int dit = 1;
int dah = 3*dit; int dah = 3*dit;
int _ = -dit; int _ = -dit;
int ___ = 3*_; int ___ = 3*_;
int _______ = 7*_; int _______ = 7*_;
const int codes[] = { const int codes[] = {
dit,_,dit,_,dit,___,dah,_,dah,_,dah,___,dit,_,dit,_,dit,_______ dit,_,dit,_,dit,___,dah,_,dah,_,dah,___,dit,_,dit,_,dit,_______
}; };
size_t s = 0; size_t s = 0;
struct input_event e; struct input_event e;
bool done = false; bool done = false;
init_debug_led(); init_debug_led();
enable_debug_led(); enable_debug_led();
do { do {
int timeout = abs(codes[s]) * ms; int timeout = abs(codes[s]) * ms;
int res = get_event(&e, timeout); int res = get_event(&e, timeout);
if (res == 0) { if (res == 0) {
if (e.type == EV_KEY if (e.type == EV_KEY
&& (e.code == KEY_HOME || e.code == KEY_VOLUMEDOWN) && (e.code == KEY_HOME || e.code == KEY_VOLUMEDOWN)
&& e.value == 0) { && e.value == 0) {
done = true; done = true;
} }
} else if (res == 1) { } else if (res == 1) {
if (++s >= sizeof(codes)/sizeof(*codes)) if (++s >= sizeof(codes)/sizeof(*codes))
s = 0; s = 0;
if (codes[s] > 0) { if (codes[s] > 0) {
enable_debug_led(); enable_debug_led();
} else { } else {
disable_debug_led(); disable_debug_led();
} }
} }
} while (!done); } while (!done);
uninit_getevent(); uninit_getevent();
} }
/* don't forget to turn debug led off */ // don't forget to turn debug led off
disable_debug_led(); disable_debug_led();
LOG("debuggerd resuming process %d", pid); LOG("debuggerd resuming process %d", pid);
} }
static int get_process_info(pid_t tid, pid_t* out_pid, uid_t* out_uid, uid_t* out_gid) { static int get_process_info(pid_t tid, pid_t* out_pid, uid_t* out_uid, uid_t* out_gid) {
char path[64]; char path[64];
snprintf(path, sizeof(path), "/proc/%d/status", tid); snprintf(path, sizeof(path), "/proc/%d/status", tid);
FILE* fp = fopen(path, "r"); FILE* fp = fopen(path, "r");
if (!fp) { if (!fp) {
return -1; return -1;
} }
int fields = 0; int fields = 0;
char line[1024]; char line[1024];
while (fgets(line, sizeof(line), fp)) { while (fgets(line, sizeof(line), fp)) {
size_t len = strlen(line); size_t len = strlen(line);
if (len > 6 && !memcmp(line, "Tgid:\t", 6)) { if (len > 6 && !memcmp(line, "Tgid:\t", 6)) {
*out_pid = atoi(line + 6); *out_pid = atoi(line + 6);
fields |= 1; fields |= 1;
} else if (len > 5 && !memcmp(line, "Uid:\t", 5)) { } else if (len > 5 && !memcmp(line, "Uid:\t", 5)) {
*out_uid = atoi(line + 5); *out_uid = atoi(line + 5);
fields |= 2; fields |= 2;
} else if (len > 5 && !memcmp(line, "Gid:\t", 5)) { } else if (len > 5 && !memcmp(line, "Gid:\t", 5)) {
*out_gid = atoi(line + 5); *out_gid = atoi(line + 5);
fields |= 4; fields |= 4;
}
} }
fclose(fp); }
return fields == 7 ? 0 : -1; fclose(fp);
return fields == 7 ? 0 : -1;
} }
static int read_request(int fd, debugger_request_t* out_request) { static int read_request(int fd, debugger_request_t* out_request) {
struct ucred cr; struct ucred cr;
int len = sizeof(cr); int len = sizeof(cr);
int status = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len); int status = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
if (status != 0) { if (status != 0) {
LOG("cannot get credentials\n"); LOG("cannot get credentials\n");
return -1; return -1;
}
XLOG("reading tid\n");
fcntl(fd, F_SETFL, O_NONBLOCK);
struct pollfd pollfds[1];
pollfds[0].fd = fd;
pollfds[0].events = POLLIN;
pollfds[0].revents = 0;
status = TEMP_FAILURE_RETRY(poll(pollfds, 1, 3000));
if (status != 1) {
LOG("timed out reading tid (from pid=%d uid=%d)\n", cr.pid, cr.uid);
return -1;
}
debugger_msg_t msg;
memset(&msg, 0, sizeof(msg));
status = TEMP_FAILURE_RETRY(read(fd, &msg, sizeof(msg)));
if (status < 0) {
LOG("read failure? %s (pid=%d uid=%d)\n", strerror(errno), cr.pid, cr.uid);
return -1;
}
if (status == sizeof(debugger_msg_t)) {
XLOG("crash request of size %d abort_msg_address=%#08x\n", status, msg.abort_msg_address);
} else {
LOG("invalid crash request of size %d (from pid=%d uid=%d)\n", status, cr.pid, cr.uid);
return -1;
}
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;
out_request->abort_msg_address = msg.abort_msg_address;
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
XLOG("reading tid\n");
fcntl(fd, F_SETFL, O_NONBLOCK);
struct pollfd pollfds[1];
pollfds[0].fd = fd;
pollfds[0].events = POLLIN;
pollfds[0].revents = 0;
status = TEMP_FAILURE_RETRY(poll(pollfds, 1, 3000));
if (status != 1) {
LOG("timed out reading tid (from pid=%d uid=%d)\n", cr.pid, cr.uid);
return -1;
}
debugger_msg_t msg;
memset(&msg, 0, sizeof(msg));
status = TEMP_FAILURE_RETRY(read(fd, &msg, sizeof(msg)));
if (status < 0) {
LOG("read failure? %s (pid=%d uid=%d)\n",
strerror(errno), cr.pid, cr.uid);
return -1;
}
if (status == sizeof(debugger_msg_t)) {
XLOG("crash request of size %d abort_msg_address=%#08x\n", status, msg.abort_msg_address);
} else {
LOG("invalid crash request of size %d (from pid=%d uid=%d)\n",
status, cr.pid, cr.uid);
return -1;
}
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;
out_request->abort_msg_address = msg.abort_msg_address;
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)) { || (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. // 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. */ // However, system is only allowed to collect backtraces but cannot dump tombstones.
status = get_process_info(out_request->tid, &out_request->pid, status = get_process_info(out_request->tid, &out_request->pid,
&out_request->uid, &out_request->gid); &out_request->uid, &out_request->gid);
if (status < 0) { if (status < 0) {
LOG("tid %d does not exist. ignoring explicit dump request\n", LOG("tid %d does not exist. ignoring explicit dump request\n", out_request->tid);
out_request->tid); return -1;
return -1;
}
} else {
/* No one else is allowed to dump arbitrary processes. */
return -1;
} }
return 0; } else {
// No one else is allowed to dump arbitrary processes.
return -1;
}
return 0;
} }
static bool should_attach_gdb(debugger_request_t* request) { static bool should_attach_gdb(debugger_request_t* request) {
if (request->action == DEBUGGER_ACTION_CRASH) { if (request->action == DEBUGGER_ACTION_CRASH) {
char value[PROPERTY_VALUE_MAX]; char value[PROPERTY_VALUE_MAX];
property_get("debug.db.uid", value, "-1"); property_get("debug.db.uid", value, "-1");
int debug_uid = atoi(value); int debug_uid = atoi(value);
return debug_uid >= 0 && request->uid <= (uid_t)debug_uid; return debug_uid >= 0 && request->uid <= (uid_t)debug_uid;
} }
return false; return false;
} }
static void handle_request(int fd) { static void handle_request(int fd) {
XLOG("handle_request(%d)\n", fd); XLOG("handle_request(%d)\n", fd);
debugger_request_t request; debugger_request_t request;
memset(&request, 0, sizeof(request)); memset(&request, 0, sizeof(request));
int status = read_request(fd, &request); int status = read_request(fd, &request);
if (!status) { if (!status) {
XLOG("BOOM: pid=%d uid=%d gid=%d tid=%d\n", XLOG("BOOM: pid=%d uid=%d gid=%d tid=%d\n",
request.pid, request.uid, request.gid, request.tid); request.pid, request.uid, request.gid, request.tid);
/* At this point, the thread that made the request is blocked in // At this point, the thread that made the request is blocked in
* a read() call. If the thread has crashed, then this gives us // a read() call. If the thread has crashed, then this gives us
* time to PTRACE_ATTACH to it before it has a chance to really fault. // time to PTRACE_ATTACH to it before it has a chance to really fault.
* //
* The PTRACE_ATTACH sends a SIGSTOP to the target process, but it // The PTRACE_ATTACH sends a SIGSTOP to the target process, but it
* won't necessarily have stopped by the time ptrace() returns. (We // won't necessarily have stopped by the time ptrace() returns. (We
* currently assume it does.) We write to the file descriptor to // currently assume it does.) We write to the file descriptor to
* ensure that it can run as soon as we call PTRACE_CONT below. // ensure that it can run as soon as we call PTRACE_CONT below.
* See details in bionic/libc/linker/debugger.c, in function // See details in bionic/libc/linker/debugger.c, in function
* debugger_signal_handler(). // debugger_signal_handler().
*/ if (ptrace(PTRACE_ATTACH, request.tid, 0, 0)) {
if (ptrace(PTRACE_ATTACH, request.tid, 0, 0)) { LOG("ptrace attach failed: %s\n", strerror(errno));
LOG("ptrace attach failed: %s\n", strerror(errno)); } else {
} else { bool detach_failed = false;
bool detach_failed = false; bool attach_gdb = should_attach_gdb(&request);
bool attach_gdb = should_attach_gdb(&request); if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) {
if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) { LOG("failed responding to client: %s\n", strerror(errno));
LOG("failed responding to client: %s\n", strerror(errno)); } else {
} else { char* tombstone_path = NULL;
char* tombstone_path = NULL;
if (request.action == DEBUGGER_ACTION_CRASH) { if (request.action == DEBUGGER_ACTION_CRASH) {
close(fd); close(fd);
fd = -1; fd = -1;
}
int total_sleep_time_usec = 0;
for (;;) {
int signal = wait_for_signal(request.tid, &total_sleep_time_usec);
if (signal < 0) {
break;
}
switch (signal) {
case SIGSTOP:
if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
XLOG("stopped -- dumping to tombstone\n");
tombstone_path = engrave_tombstone(request.pid, request.tid,
signal, request.abort_msg_address, 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, -1,
request.pid, request.tid, &detach_failed,
&total_sleep_time_usec);
} else {
XLOG("stopped -- continuing\n");
status = ptrace(PTRACE_CONT, request.tid, 0, 0);
if (status) {
LOG("ptrace continue failed: %s\n", strerror(errno));
}
continue; /* loop again */
}
break;
case SIGILL:
case SIGABRT:
case SIGBUS:
case SIGFPE:
case SIGSEGV:
case SIGPIPE:
#ifdef SIGSTKFLT
case SIGSTKFLT:
#endif
{
XLOG("stopped -- fatal signal\n");
/*
* Send a SIGSTOP to the process to make all of
* the non-signaled threads stop moving. Without
* this we get a lot of "ptrace detach failed:
* No such process".
*/
kill(request.pid, SIGSTOP);
/* 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, request.abort_msg_address, !attach_gdb, false,
&detach_failed, &total_sleep_time_usec);
break;
}
default:
XLOG("stopped -- unexpected signal\n");
LOG("process stopped due to unexpected signal %d\n", signal);
break;
}
break;
}
if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
if (tombstone_path) {
write(fd, tombstone_path, strlen(tombstone_path));
}
close(fd);
fd = -1;
}
free(tombstone_path);
}
XLOG("detaching\n");
if (attach_gdb) {
/* stop the process so we can debug */
kill(request.pid, SIGSTOP);
/* detach so we can attach gdbserver */
if (ptrace(PTRACE_DETACH, request.tid, 0, 0)) {
LOG("ptrace detach from %d failed: %s\n", request.tid, strerror(errno));
detach_failed = true;
}
/*
* if debug.db.uid is set, its value indicates if we should wait
* for user action for the crashing process.
* in this case, we log a message and turn the debug LED on
* waiting for a gdb connection (for instance)
*/
wait_for_user_action(request.pid);
} else {
/* just detach */
if (ptrace(PTRACE_DETACH, request.tid, 0, 0)) {
LOG("ptrace detach from %d failed: %s\n", request.tid, strerror(errno));
detach_failed = true;
}
}
/* resume stopped process (so it can crash in peace). */
kill(request.pid, SIGCONT);
/* If we didn't successfully detach, we're still the parent, and the
* actual parent won't receive a death notification via wait(2). At this point
* there's not much we can do about that. */
if (detach_failed) {
LOG("debuggerd committing suicide to free the zombie!\n");
kill(getpid(), SIGKILL);
}
} }
int total_sleep_time_usec = 0;
for (;;) {
int signal = wait_for_signal(request.tid, &total_sleep_time_usec);
if (signal < 0) {
break;
}
switch (signal) {
case SIGSTOP:
if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
XLOG("stopped -- dumping to tombstone\n");
tombstone_path = engrave_tombstone(
request.pid, request.tid, signal, request.abort_msg_address, 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, -1, request.pid, request.tid, &detach_failed,
&total_sleep_time_usec);
} else {
XLOG("stopped -- continuing\n");
status = ptrace(PTRACE_CONT, request.tid, 0, 0);
if (status) {
LOG("ptrace continue failed: %s\n", strerror(errno));
}
continue; // loop again
}
break;
case SIGILL:
case SIGABRT:
case SIGBUS:
case SIGFPE:
case SIGSEGV:
case SIGPIPE:
#ifdef SIGSTKFLT
case SIGSTKFLT:
#endif
XLOG("stopped -- fatal signal\n");
// Send a SIGSTOP to the process to make all of
// the non-signaled threads stop moving. Without
// this we get a lot of "ptrace detach failed:
// No such process".
kill(request.pid, SIGSTOP);
// 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, request.abort_msg_address, !attach_gdb,
false, &detach_failed, &total_sleep_time_usec);
break;
default:
XLOG("stopped -- unexpected signal\n");
LOG("process stopped due to unexpected signal %d\n", signal);
break;
}
break;
}
if (request.action == DEBUGGER_ACTION_DUMP_TOMBSTONE) {
if (tombstone_path) {
write(fd, tombstone_path, strlen(tombstone_path));
}
close(fd);
fd = -1;
}
free(tombstone_path);
}
XLOG("detaching\n");
if (attach_gdb) {
// stop the process so we can debug
kill(request.pid, SIGSTOP);
// detach so we can attach gdbserver
if (ptrace(PTRACE_DETACH, request.tid, 0, 0)) {
LOG("ptrace detach from %d failed: %s\n", request.tid, strerror(errno));
detach_failed = true;
}
// if debug.db.uid is set, its value indicates if we should wait
// for user action for the crashing process.
// in this case, we log a message and turn the debug LED on
// waiting for a gdb connection (for instance)
wait_for_user_action(request.pid);
} else {
// just detach
if (ptrace(PTRACE_DETACH, request.tid, 0, 0)) {
LOG("ptrace detach from %d failed: %s\n", request.tid, strerror(errno));
detach_failed = true;
}
}
// resume stopped process (so it can crash in peace).
kill(request.pid, SIGCONT);
// If we didn't successfully detach, we're still the parent, and the
// actual parent won't receive a death notification via wait(2). At this point
// there's not much we can do about that.
if (detach_failed) {
LOG("debuggerd committing suicide to free the zombie!\n");
kill(getpid(), SIGKILL);
}
} }
if (fd >= 0) {
close(fd); }
} if (fd >= 0) {
close(fd);
}
} }
static int do_server() { static int do_server() {
int s; int s;
struct sigaction act; struct sigaction act;
int logsocket = -1; int logsocket = -1;
/* // debuggerd crashes can't be reported to debuggerd. Reset all of the
* debuggerd crashes can't be reported to debuggerd. Reset all of the // crash handlers.
* crash handlers. signal(SIGILL, SIG_DFL);
*/ signal(SIGABRT, SIG_DFL);
signal(SIGILL, SIG_DFL); signal(SIGBUS, SIG_DFL);
signal(SIGABRT, SIG_DFL); signal(SIGFPE, SIG_DFL);
signal(SIGBUS, SIG_DFL); signal(SIGSEGV, SIG_DFL);
signal(SIGFPE, SIG_DFL);
signal(SIGSEGV, SIG_DFL);
#ifdef SIGSTKFLT #ifdef SIGSTKFLT
signal(SIGSTKFLT, SIG_DFL); signal(SIGSTKFLT, SIG_DFL);
#endif #endif
// Ignore failed writes to closed sockets // Ignore failed writes to closed sockets
signal(SIGPIPE, SIG_IGN); signal(SIGPIPE, SIG_IGN);
logsocket = socket_local_client("logd", logsocket = socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM);
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM); if (logsocket < 0) {
if(logsocket < 0) { logsocket = -1;
logsocket = -1; } else {
} else { fcntl(logsocket, F_SETFD, FD_CLOEXEC);
fcntl(logsocket, F_SETFD, FD_CLOEXEC); }
act.sa_handler = SIG_DFL;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask,SIGCHLD);
act.sa_flags = SA_NOCLDWAIT;
sigaction(SIGCHLD, &act, 0);
s = socket_local_server(DEBUGGER_SOCKET_NAME, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
if (s < 0)
return 1;
fcntl(s, F_SETFD, FD_CLOEXEC);
LOG("debuggerd: " __DATE__ " " __TIME__ "\n");
for (;;) {
struct sockaddr addr;
socklen_t alen;
int fd;
alen = sizeof(addr);
XLOG("waiting for connection\n");
fd = accept(s, &addr, &alen);
if (fd < 0) {
XLOG("accept failed: %s\n", strerror(errno));
continue;
} }
act.sa_handler = SIG_DFL; fcntl(fd, F_SETFD, FD_CLOEXEC);
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask,SIGCHLD);
act.sa_flags = SA_NOCLDWAIT;
sigaction(SIGCHLD, &act, 0);
s = socket_local_server(DEBUGGER_SOCKET_NAME, handle_request(fd);
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); }
if(s < 0) return 1; return 0;
fcntl(s, F_SETFD, FD_CLOEXEC);
LOG("debuggerd: " __DATE__ " " __TIME__ "\n");
for(;;) {
struct sockaddr addr;
socklen_t alen;
int fd;
alen = sizeof(addr);
XLOG("waiting for connection\n");
fd = accept(s, &addr, &alen);
if(fd < 0) {
XLOG("accept failed: %s\n", strerror(errno));
continue;
}
fcntl(fd, F_SETFD, FD_CLOEXEC);
handle_request(fd);
}
return 0;
} }
static int do_explicit_dump(pid_t tid, bool dump_backtrace) { static int do_explicit_dump(pid_t tid, bool dump_backtrace) {
fprintf(stdout, "Sending request to dump task %d.\n", tid); fprintf(stdout, "Sending request to dump task %d.\n", tid);
if (dump_backtrace) { if (dump_backtrace) {
fflush(stdout); fflush(stdout);
if (dump_backtrace_to_file(tid, fileno(stdout)) < 0) { if (dump_backtrace_to_file(tid, fileno(stdout)) < 0) {
fputs("Error dumping backtrace.\n", stderr); fputs("Error dumping backtrace.\n", stderr);
return 1; return 1;
}
} else {
char tombstone_path[PATH_MAX];
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);
} }
return 0; } else {
char tombstone_path[PATH_MAX];
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);
}
return 0;
} }
static void usage() { static void usage() {
fputs("Usage: -b [<tid>]\n" fputs("Usage: -b [<tid>]\n"
" -b dump backtrace to console, otherwise dump full tombstone file\n" " -b dump backtrace to console, otherwise dump full tombstone file\n"
"\n" "\n"
"If tid specified, sends a request to debuggerd to dump that task.\n" "If tid specified, sends a request to debuggerd to dump that task.\n"
"Otherwise, starts the debuggerd server.\n", stderr); "Otherwise, starts the debuggerd server.\n", stderr);
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
if (argc == 1) { if (argc == 1) {
return do_server(); return do_server();
} }
bool dump_backtrace = false; bool dump_backtrace = false;
bool have_tid = false; bool have_tid = false;
pid_t tid = 0; pid_t tid = 0;
for (int i = 1; i < argc; i++) { for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-b")) { if (!strcmp(argv[i], "-b")) {
dump_backtrace = true; dump_backtrace = true;
} else if (!have_tid) { } else if (!have_tid) {
tid = atoi(argv[i]); tid = atoi(argv[i]);
have_tid = true; have_tid = true;
} else { } else {
usage(); usage();
return 1; return 1;
}
} }
if (!have_tid) { }
usage(); if (!have_tid) {
return 1; usage();
} return 1;
return do_explicit_dump(tid, dump_backtrace); }
return do_explicit_dump(tid, dump_backtrace);
} }

373
debuggerd/getevent.cpp
View file

@ -1,3 +1,19 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -12,208 +28,195 @@
#include <errno.h> #include <errno.h>
#include <cutils/log.h> #include <cutils/log.h>
static struct pollfd *ufds; static struct pollfd* ufds;
static char **device_names; static char** device_names;
static int nfds; static int nfds;
static int open_device(const char *device) static int open_device(const char* device) {
{ int version;
int version; int fd;
int fd; struct pollfd* new_ufds;
struct pollfd *new_ufds; char** new_device_names;
char **new_device_names; char name[80];
char name[80]; char location[80];
char location[80]; char idstr[80];
char idstr[80]; struct input_id id;
struct input_id id;
fd = open(device, O_RDWR); fd = open(device, O_RDWR);
if(fd < 0) { if (fd < 0) {
return -1;
}
if(ioctl(fd, EVIOCGVERSION, &version)) {
return -1;
}
if(ioctl(fd, EVIOCGID, &id)) {
return -1;
}
name[sizeof(name) - 1] = '\0';
location[sizeof(location) - 1] = '\0';
idstr[sizeof(idstr) - 1] = '\0';
if(ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {
//fprintf(stderr, "could not get device name for %s, %s\n", device, strerror(errno));
name[0] = '\0';
}
if(ioctl(fd, EVIOCGPHYS(sizeof(location) - 1), &location) < 1) {
//fprintf(stderr, "could not get location for %s, %s\n", device, strerror(errno));
location[0] = '\0';
}
if(ioctl(fd, EVIOCGUNIQ(sizeof(idstr) - 1), &idstr) < 1) {
//fprintf(stderr, "could not get idstring for %s, %s\n", device, strerror(errno));
idstr[0] = '\0';
}
new_ufds = reinterpret_cast<pollfd*>(realloc(ufds, sizeof(ufds[0]) * (nfds + 1)));
if(new_ufds == NULL) {
fprintf(stderr, "out of memory\n");
return -1;
}
ufds = new_ufds;
new_device_names = reinterpret_cast<char**>(realloc(device_names, sizeof(device_names[0]) * (nfds + 1)));
if(new_device_names == NULL) {
fprintf(stderr, "out of memory\n");
return -1;
}
device_names = new_device_names;
ufds[nfds].fd = fd;
ufds[nfds].events = POLLIN;
device_names[nfds] = strdup(device);
nfds++;
return 0;
}
int close_device(const char *device)
{
int i;
for(i = 1; i < nfds; i++) {
if(strcmp(device_names[i], device) == 0) {
int count = nfds - i - 1;
free(device_names[i]);
memmove(device_names + i, device_names + i + 1, sizeof(device_names[0]) * count);
memmove(ufds + i, ufds + i + 1, sizeof(ufds[0]) * count);
nfds--;
return 0;
}
}
return -1; return -1;
}
if (ioctl(fd, EVIOCGVERSION, &version)) {
return -1;
}
if (ioctl(fd, EVIOCGID, &id)) {
return -1;
}
name[sizeof(name) - 1] = '\0';
location[sizeof(location) - 1] = '\0';
idstr[sizeof(idstr) - 1] = '\0';
if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {
name[0] = '\0';
}
if (ioctl(fd, EVIOCGPHYS(sizeof(location) - 1), &location) < 1) {
location[0] = '\0';
}
if (ioctl(fd, EVIOCGUNIQ(sizeof(idstr) - 1), &idstr) < 1) {
idstr[0] = '\0';
}
new_ufds = reinterpret_cast<pollfd*>(realloc(ufds, sizeof(ufds[0]) * (nfds + 1)));
if (new_ufds == NULL) {
fprintf(stderr, "out of memory\n");
return -1;
}
ufds = new_ufds;
new_device_names = reinterpret_cast<char**>(realloc(
device_names, sizeof(device_names[0]) * (nfds + 1)));
if (new_device_names == NULL) {
fprintf(stderr, "out of memory\n");
return -1;
}
device_names = new_device_names;
ufds[nfds].fd = fd;
ufds[nfds].events = POLLIN;
device_names[nfds] = strdup(device);
nfds++;
return 0;
} }
static int read_notify(const char *dirname, int nfd) int close_device(const char* device) {
{ int i;
int res; for (i = 1; i < nfds; i++) {
char devname[PATH_MAX]; if (strcmp(device_names[i], device) == 0) {
char *filename; int count = nfds - i - 1;
char event_buf[512]; free(device_names[i]);
int event_size; memmove(device_names + i, device_names + i + 1, sizeof(device_names[0]) * count);
int event_pos = 0; memmove(ufds + i, ufds + i + 1, sizeof(ufds[0]) * count);
struct inotify_event *event; nfds--;
return 0;
res = read(nfd, event_buf, sizeof(event_buf));
if(res < (int)sizeof(*event)) {
if(errno == EINTR)
return 0;
fprintf(stderr, "could not get event, %s\n", strerror(errno));
return 1;
} }
//printf("got %d bytes of event information\n", res); }
return -1;
strcpy(devname, dirname);
filename = devname + strlen(devname);
*filename++ = '/';
while(res >= (int)sizeof(*event)) {
event = (struct inotify_event *)(event_buf + event_pos);
//printf("%d: %08x \"%s\"\n", event->wd, event->mask, event->len ? event->name : "");
if(event->len) {
strcpy(filename, event->name);
if(event->mask & IN_CREATE) {
open_device(devname);
}
else {
close_device(devname);
}
}
event_size = sizeof(*event) + event->len;
res -= event_size;
event_pos += event_size;
}
return 0;
} }
static int scan_dir(const char *dirname) static int read_notify(const char* dirname, int nfd) {
{ int res;
char devname[PATH_MAX]; char devname[PATH_MAX];
char *filename; char* filename;
DIR *dir; char event_buf[512];
struct dirent *de; int event_size;
dir = opendir(dirname); int event_pos = 0;
if(dir == NULL) struct inotify_event *event;
return -1;
strcpy(devname, dirname); res = read(nfd, event_buf, sizeof(event_buf));
filename = devname + strlen(devname); if (res < (int)sizeof(*event)) {
*filename++ = '/'; if (errno == EINTR)
while((de = readdir(dir))) { return 0;
if(de->d_name[0] == '.' && fprintf(stderr, "could not get event, %s\n", strerror(errno));
(de->d_name[1] == '\0' || return 1;
(de->d_name[1] == '.' && de->d_name[2] == '\0'))) }
continue;
strcpy(filename, de->d_name); strcpy(devname, dirname);
filename = devname + strlen(devname);
*filename++ = '/';
while (res >= (int)sizeof(*event)) {
event = reinterpret_cast<struct inotify_event*>(event_buf + event_pos);
if (event->len) {
strcpy(filename, event->name);
if (event->mask & IN_CREATE) {
open_device(devname); open_device(devname);
} else {
close_device(devname);
}
} }
closedir(dir); event_size = sizeof(*event) + event->len;
return 0; res -= event_size;
event_pos += event_size;
}
return 0;
} }
int init_getevent() static int scan_dir(const char* dirname) {
{ char devname[PATH_MAX];
int res; char* filename;
const char *device_path = "/dev/input"; DIR* dir;
struct dirent* de;
nfds = 1; dir = opendir(dirname);
ufds = reinterpret_cast<pollfd*>(calloc(1, sizeof(ufds[0]))); if (dir == NULL)
ufds[0].fd = inotify_init(); return -1;
ufds[0].events = POLLIN; strcpy(devname, dirname);
filename = devname + strlen(devname);
res = inotify_add_watch(ufds[0].fd, device_path, IN_DELETE | IN_CREATE); *filename++ = '/';
if(res < 0) { while ((de = readdir(dir))) {
return 1; if ((de->d_name[0] == '.' && de->d_name[1] == '\0') ||
} (de->d_name[1] == '.' && de->d_name[2] == '\0'))
res = scan_dir(device_path); continue;
if(res < 0) { strcpy(filename, de->d_name);
return 1; open_device(devname);
} }
return 0; closedir(dir);
return 0;
} }
void uninit_getevent() int init_getevent() {
{ int res;
int i; const char* device_path = "/dev/input";
for(i = 0; i < nfds; i++) {
close(ufds[i].fd); nfds = 1;
} ufds = reinterpret_cast<pollfd*>(calloc(1, sizeof(ufds[0])));
free(ufds); ufds[0].fd = inotify_init();
ufds = 0; ufds[0].events = POLLIN;
nfds = 0;
res = inotify_add_watch(ufds[0].fd, device_path, IN_DELETE | IN_CREATE);
if (res < 0) {
return 1;
}
res = scan_dir(device_path);
if (res < 0) {
return 1;
}
return 0;
} }
int get_event(struct input_event* event, int timeout) void uninit_getevent() {
{ int i;
int res; for (i = 0; i < nfds; i++) {
int i; close(ufds[i].fd);
int pollres; }
const char *device_path = "/dev/input"; free(ufds);
while(1) { ufds = 0;
pollres = poll(ufds, nfds, timeout); nfds = 0;
if (pollres == 0) { }
return 1;
} int get_event(struct input_event* event, int timeout) {
if(ufds[0].revents & POLLIN) { int res;
read_notify(device_path, ufds[0].fd); int i;
} int pollres;
for(i = 1; i < nfds; i++) { const char* device_path = "/dev/input";
if(ufds[i].revents) { while (1) {
if(ufds[i].revents & POLLIN) { pollres = poll(ufds, nfds, timeout);
res = read(ufds[i].fd, event, sizeof(*event)); if (pollres == 0) {
if(res < (int)sizeof(event)) { return 1;
fprintf(stderr, "could not get event\n"); }
return -1; if (ufds[0].revents & POLLIN) {
} read_notify(device_path, ufds[0].fd);
return 0; }
} for (i = 1; i < nfds; i++) {
} if (ufds[i].revents) {
if (ufds[i].revents & POLLIN) {
res = read(ufds[i].fd, event, sizeof(*event));
if (res < static_cast<int>(sizeof(event))) {
fprintf(stderr, "could not get event\n");
return -1;
}
return 0;
} }
}
} }
return 0; }
return 0;
} }

260
debuggerd/mips/machine.cpp
View file

@ -1,22 +1,20 @@
/* system/debuggerd/debuggerd.c /*
** * Copyright 2012, The Android Open Source Project
** Copyright 2012, The Android Open Source Project *
** * Licensed under the Apache License, Version 2.0 (the "License");
** Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License.
** you may not use this file except in compliance with the License. * You may obtain a copy of the License at
** You may obtain a copy of the License at *
** * http://www.apache.org/licenses/LICENSE-2.0
** http://www.apache.org/licenses/LICENSE-2.0 *
** * Unless required by applicable law or agreed to in writing, software
** Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS,
** distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and
** See the License for the specific language governing permissions and * limitations under the License.
** limitations under the License. */
*/
#include <stddef.h> #include <stddef.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
@ -31,144 +29,134 @@
#include "../utility.h" #include "../utility.h"
#include "../machine.h" #include "../machine.h"
/* enable to dump memory pointed to by every register */ // enable to dump memory pointed to by every register
#define DUMP_MEMORY_FOR_ALL_REGISTERS 1 #define DUMP_MEMORY_FOR_ALL_REGISTERS 1
#define R(x) ((unsigned int)(x)) #define R(x) (static_cast<unsigned int>(x))
static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, int scope_flags) { static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, int scope_flags) {
char code_buffer[64]; /* actual 8+1+((8+1)*4) + 1 == 45 */ char code_buffer[64]; // actual 8+1+((8+1)*4) + 1 == 45
char ascii_buffer[32]; /* actual 16 + 1 == 17 */ char ascii_buffer[32]; // actual 16 + 1 == 17
uintptr_t p, end; uintptr_t p, end;
p = addr & ~3; p = addr & ~3;
p -= 32; p -= 32;
if (p > addr) { if (p > addr) {
/* catch underflow */ // catch underflow
p = 0; p = 0;
} }
end = p + 80; end = p + 80;
/* catch overflow; 'end - p' has to be multiples of 16 */ // catch overflow; 'end - p' has to be multiples of 16
while (end < p) while (end < p)
end -= 16; end -= 16;
/* Dump the code around PC as: // Dump the code around PC as:
* addr contents ascii // addr contents ascii
* 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q // 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q
* 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p...... // 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p......
*/ while (p < end) {
while (p < end) { char* asc_out = ascii_buffer;
char* asc_out = ascii_buffer;
sprintf(code_buffer, "%08x ", p); sprintf(code_buffer, "%08x ", p);
int i; int i;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
/* // If we see (data == -1 && errno != 0), we know that the ptrace
* If we see (data == -1 && errno != 0), we know that the ptrace // call failed, probably because we're dumping memory in an
* call failed, probably because we're dumping memory in an // unmapped or inaccessible page. I don't know if there's
* unmapped or inaccessible page. I don't know if there's // value in making that explicit in the output -- it likely
* value in making that explicit in the output -- it likely // just complicates parsing and clarifies nothing for the
* just complicates parsing and clarifies nothing for the // enlightened reader.
* enlightened reader. long data = ptrace(PTRACE_PEEKTEXT, tid, (void*)p, NULL);
*/ sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
long data = ptrace(PTRACE_PEEKTEXT, tid, (void*)p, NULL);
sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
int j; int j;
for (j = 0; j < 4; j++) { for (j = 0; j < 4; j++) {
/* // Our isprint() allows high-ASCII characters that display
* Our isprint() allows high-ASCII characters that display // differently (often badly) in different viewers, so we
* differently (often badly) in different viewers, so we // just use a simpler test.
* just use a simpler test. char val = (data >> (j*8)) & 0xff;
*/ if (val >= 0x20 && val < 0x7f) {
char val = (data >> (j*8)) & 0xff; *asc_out++ = val;
if (val >= 0x20 && val < 0x7f) { } else {
*asc_out++ = val; *asc_out++ = '.';
} else {
*asc_out++ = '.';
}
}
p += 4;
} }
*asc_out = '\0'; }
_LOG(log, scope_flags, " %s %s\n", code_buffer, ascii_buffer); p += 4;
} }
*asc_out = '\0';
_LOG(log, scope_flags, " %s %s\n", code_buffer, ascii_buffer);
}
} }
/* // If configured to do so, dump memory around *all* registers
* If configured to do so, dump memory around *all* registers // for the crashing thread.
* for the crashing thread.
*/
void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) { void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
pt_regs_mips_t r; pt_regs_mips_t r;
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) { if (ptrace(PTRACE_GETREGS, tid, 0, &r)) {
return; return;
}
if (IS_AT_FAULT(scope_flags) && DUMP_MEMORY_FOR_ALL_REGISTERS) {
static const char REG_NAMES[] = "$0atv0v1a0a1a2a3t0t1t2t3t4t5t6t7s0s1s2s3s4s5s6s7t8t9k0k1gpsps8ra";
for (int reg = 0; reg < 32; reg++) {
// skip uninteresting registers
if (reg == 0 // $0
|| reg == 26 // $k0
|| reg == 27 // $k1
|| reg == 31 // $ra (done below)
)
continue;
uintptr_t addr = R(r.regs[reg]);
// Don't bother if it looks like a small int or ~= null, or if
// it's in the kernel area.
if (addr < 4096 || addr >= 0x80000000) {
continue;
}
_LOG(log, scope_flags | SCOPE_SENSITIVE, "\nmemory near %.2s:\n", &REG_NAMES[reg * 2]);
dump_memory(log, tid, addr, scope_flags | SCOPE_SENSITIVE);
} }
}
if (IS_AT_FAULT(scope_flags) && DUMP_MEMORY_FOR_ALL_REGISTERS) { unsigned int pc = R(r.cp0_epc);
static const char REG_NAMES[] = "$0atv0v1a0a1a2a3t0t1t2t3t4t5t6t7s0s1s2s3s4s5s6s7t8t9k0k1gpsps8ra"; unsigned int ra = R(r.regs[31]);
for (int reg = 0; reg < 32; reg++) { _LOG(log, scope_flags, "\ncode around pc:\n");
/* skip uninteresting registers */ dump_memory(log, tid, (uintptr_t)pc, scope_flags);
if (reg == 0 /* $0 */
|| reg == 26 /* $k0 */
|| reg == 27 /* $k1 */
|| reg == 31 /* $ra (done below) */
)
continue;
uintptr_t addr = R(r.regs[reg]); if (pc != ra) {
_LOG(log, scope_flags, "\ncode around ra:\n");
/* dump_memory(log, tid, (uintptr_t)ra, scope_flags);
* Don't bother if it looks like a small int or ~= null, or if }
* it's in the kernel area.
*/
if (addr < 4096 || addr >= 0x80000000) {
continue;
}
_LOG(log, scope_flags | SCOPE_SENSITIVE, "\nmemory near %.2s:\n", &REG_NAMES[reg * 2]);
dump_memory(log, tid, addr, scope_flags | SCOPE_SENSITIVE);
}
}
unsigned int pc = R(r.cp0_epc);
unsigned int ra = R(r.regs[31]);
_LOG(log, scope_flags, "\ncode around pc:\n");
dump_memory(log, tid, (uintptr_t)pc, scope_flags);
if (pc != ra) {
_LOG(log, scope_flags, "\ncode around ra:\n");
dump_memory(log, tid, (uintptr_t)ra, scope_flags);
}
} }
void dump_registers(log_t* log, pid_t tid, int scope_flags) void dump_registers(log_t* log, pid_t tid, int scope_flags) {
{ pt_regs_mips_t r;
pt_regs_mips_t r; if(ptrace(PTRACE_GETREGS, tid, 0, &r)) {
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) { _LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno)); return;
return; }
}
_LOG(log, scope_flags, " zr %08x at %08x v0 %08x v1 %08x\n", _LOG(log, scope_flags, " zr %08x at %08x v0 %08x v1 %08x\n",
R(r.regs[0]), R(r.regs[1]), R(r.regs[2]), R(r.regs[3])); R(r.regs[0]), R(r.regs[1]), R(r.regs[2]), R(r.regs[3]));
_LOG(log, scope_flags, " a0 %08x a1 %08x a2 %08x a3 %08x\n", _LOG(log, scope_flags, " a0 %08x a1 %08x a2 %08x a3 %08x\n",
R(r.regs[4]), R(r.regs[5]), R(r.regs[6]), R(r.regs[7])); R(r.regs[4]), R(r.regs[5]), R(r.regs[6]), R(r.regs[7]));
_LOG(log, scope_flags, " t0 %08x t1 %08x t2 %08x t3 %08x\n", _LOG(log, scope_flags, " t0 %08x t1 %08x t2 %08x t3 %08x\n",
R(r.regs[8]), R(r.regs[9]), R(r.regs[10]), R(r.regs[11])); R(r.regs[8]), R(r.regs[9]), R(r.regs[10]), R(r.regs[11]));
_LOG(log, scope_flags, " t4 %08x t5 %08x t6 %08x t7 %08x\n", _LOG(log, scope_flags, " t4 %08x t5 %08x t6 %08x t7 %08x\n",
R(r.regs[12]), R(r.regs[13]), R(r.regs[14]), R(r.regs[15])); R(r.regs[12]), R(r.regs[13]), R(r.regs[14]), R(r.regs[15]));
_LOG(log, scope_flags, " s0 %08x s1 %08x s2 %08x s3 %08x\n", _LOG(log, scope_flags, " s0 %08x s1 %08x s2 %08x s3 %08x\n",
R(r.regs[16]), R(r.regs[17]), R(r.regs[18]), R(r.regs[19])); R(r.regs[16]), R(r.regs[17]), R(r.regs[18]), R(r.regs[19]));
_LOG(log, scope_flags, " s4 %08x s5 %08x s6 %08x s7 %08x\n", _LOG(log, scope_flags, " s4 %08x s5 %08x s6 %08x s7 %08x\n",
R(r.regs[20]), R(r.regs[21]), R(r.regs[22]), R(r.regs[23])); R(r.regs[20]), R(r.regs[21]), R(r.regs[22]), R(r.regs[23]));
_LOG(log, scope_flags, " t8 %08x t9 %08x k0 %08x k1 %08x\n", _LOG(log, scope_flags, " t8 %08x t9 %08x k0 %08x k1 %08x\n",
R(r.regs[24]), R(r.regs[25]), R(r.regs[26]), R(r.regs[27])); R(r.regs[24]), R(r.regs[25]), R(r.regs[26]), R(r.regs[27]));
_LOG(log, scope_flags, " gp %08x sp %08x s8 %08x ra %08x\n", _LOG(log, scope_flags, " gp %08x sp %08x s8 %08x ra %08x\n",
R(r.regs[28]), R(r.regs[29]), R(r.regs[30]), R(r.regs[31])); R(r.regs[28]), R(r.regs[29]), R(r.regs[30]), R(r.regs[31]));
_LOG(log, scope_flags, " hi %08x lo %08x bva %08x epc %08x\n", _LOG(log, scope_flags, " hi %08x lo %08x bva %08x epc %08x\n",
R(r.hi), R(r.lo), R(r.cp0_badvaddr), R(r.cp0_epc)); R(r.hi), R(r.lo), R(r.cp0_badvaddr), R(r.cp0_epc));
} }

1172
debuggerd/tombstone.cpp
View file

File diff suppressed because it is too large Load diff

2
debuggerd/tombstone.h
View file

@ -21,8 +21,6 @@
#include <stdbool.h> #include <stdbool.h>
#include <sys/types.h> #include <sys/types.h>
#include <corkscrew/ptrace.h>
/* Creates a tombstone file and writes the crash dump to it. /* Creates a tombstone file and writes the crash dump to it.
* Returns the path of the tombstone, which must be freed using free(). */ * Returns the path of the tombstone, which must be freed using free(). */
char* engrave_tombstone(pid_t pid, pid_t tid, int signal, uintptr_t abort_msg_address, char* engrave_tombstone(pid_t pid, pid_t tid, int signal, uintptr_t abort_msg_address,

193
debuggerd/utility.cpp
View file

@ -1,22 +1,20 @@
/* system/debuggerd/utility.c /*
** * Copyright 2008, The Android Open Source Project
** Copyright 2008, The Android Open Source Project *
** * Licensed under the Apache License, Version 2.0 (the "License");
** Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License.
** you may not use this file except in compliance with the License. * You may obtain a copy of the License at
** You may obtain a copy of the License at *
** * http://www.apache.org/licenses/LICENSE-2.0
** http://www.apache.org/licenses/LICENSE-2.0 *
** * Unless required by applicable law or agreed to in writing, software
** Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS,
** distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and
** See the License for the specific language governing permissions and * limitations under the License.
** limitations under the License. */
*/
#include <stddef.h> #include <stddef.h>
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
@ -30,101 +28,102 @@
#include "utility.h" #include "utility.h"
const int sleep_time_usec = 50000; /* 0.05 seconds */ const int sleep_time_usec = 50000; // 0.05 seconds
const int max_total_sleep_usec = 10000000; /* 10 seconds */ const int max_total_sleep_usec = 10000000; // 10 seconds
static int write_to_am(int fd, const char* buf, int len) { static int write_to_am(int fd, const char* buf, int len) {
int to_write = len; int to_write = len;
while (to_write > 0) { while (to_write > 0) {
int written = TEMP_FAILURE_RETRY( write(fd, buf + len - to_write, to_write) ); int written = TEMP_FAILURE_RETRY( write(fd, buf + len - to_write, to_write) );
if (written < 0) { if (written < 0) {
/* hard failure */ // hard failure
LOG("AM write failure (%d / %s)\n", errno, strerror(errno)); LOG("AM write failure (%d / %s)\n", errno, strerror(errno));
return -1; return -1;
}
to_write -= written;
} }
return len; to_write -= written;
}
return len;
} }
void _LOG(log_t* log, int scopeFlags, const char *fmt, ...) { void _LOG(log_t* log, int scopeFlags, const char* fmt, ...) {
char buf[512]; char buf[512];
bool want_tfd_write; bool want_tfd_write;
bool want_log_write; bool want_log_write;
bool want_amfd_write; bool want_amfd_write;
int len = 0; int len = 0;
va_list ap; va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
// where is the information going to go? // where is the information going to go?
want_tfd_write = log && log->tfd >= 0; want_tfd_write = log && log->tfd >= 0;
want_log_write = IS_AT_FAULT(scopeFlags) && (!log || !log->quiet); want_log_write = IS_AT_FAULT(scopeFlags) && (!log || !log->quiet);
want_amfd_write = IS_AT_FAULT(scopeFlags) && !IS_SENSITIVE(scopeFlags) && log && log->amfd >= 0; want_amfd_write = IS_AT_FAULT(scopeFlags) && !IS_SENSITIVE(scopeFlags) && log && log->amfd >= 0;
// if we're going to need the literal string, generate it once here // if we're going to need the literal string, generate it once here
if (want_tfd_write || want_amfd_write) { if (want_tfd_write || want_amfd_write) {
vsnprintf(buf, sizeof(buf), fmt, ap); vsnprintf(buf, sizeof(buf), fmt, ap);
len = strlen(buf); len = strlen(buf);
}
if (want_tfd_write) {
write(log->tfd, buf, len);
}
if (want_log_write) {
// whatever goes to logcat also goes to the Activity Manager
__android_log_vprint(ANDROID_LOG_INFO, "DEBUG", fmt, ap);
if (want_amfd_write && len > 0) {
int written = write_to_am(log->amfd, buf, len);
if (written <= 0) {
// timeout or other failure on write; stop informing the activity manager
log->amfd = -1;
}
} }
}
if (want_tfd_write) { va_end(ap);
write(log->tfd, buf, len);
}
if (want_log_write) {
// whatever goes to logcat also goes to the Activity Manager
__android_log_vprint(ANDROID_LOG_INFO, "DEBUG", fmt, ap);
if (want_amfd_write && len > 0) {
int written = write_to_am(log->amfd, buf, len);
if (written <= 0) {
// timeout or other failure on write; stop informing the activity manager
log->amfd = -1;
}
}
}
va_end(ap);
} }
int wait_for_signal(pid_t tid, int* total_sleep_time_usec) { int wait_for_signal(pid_t tid, int* total_sleep_time_usec) {
for (;;) { for (;;) {
int status; int status;
pid_t n = waitpid(tid, &status, __WALL | WNOHANG); pid_t n = waitpid(tid, &status, __WALL | WNOHANG);
if (n < 0) { if (n < 0) {
if(errno == EAGAIN) continue; if (errno == EAGAIN)
LOG("waitpid failed: %s\n", strerror(errno)); continue;
return -1; LOG("waitpid failed: %s\n", strerror(errno));
} else if (n > 0) { return -1;
XLOG("waitpid: n=%d status=%08x\n", n, status); } else if (n > 0) {
if (WIFSTOPPED(status)) { XLOG("waitpid: n=%d status=%08x\n", n, status);
return WSTOPSIG(status); if (WIFSTOPPED(status)) {
} else { return WSTOPSIG(status);
LOG("unexpected waitpid response: n=%d, status=%08x\n", n, status); } else {
return -1; 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;
} }
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;
}
} }
void wait_for_stop(pid_t tid, int* total_sleep_time_usec) { void wait_for_stop(pid_t tid, int* total_sleep_time_usec) {
siginfo_t si; siginfo_t si;
while (TEMP_FAILURE_RETRY(ptrace(PTRACE_GETSIGINFO, tid, 0, &si)) < 0 && errno == ESRCH) { while (TEMP_FAILURE_RETRY(ptrace(PTRACE_GETSIGINFO, tid, 0, &si)) < 0 && errno == ESRCH) {
if (*total_sleep_time_usec > max_total_sleep_usec) { if (*total_sleep_time_usec > max_total_sleep_usec) {
LOG("timed out waiting for tid=%d to stop\n", tid); LOG("timed out waiting for tid=%d to stop\n", tid);
break; break;
}
usleep(sleep_time_usec);
*total_sleep_time_usec += sleep_time_usec;
} }
usleep(sleep_time_usec);
*total_sleep_time_usec += sleep_time_usec;
}
} }

55
debuggerd/x86/machine.cpp
View file

@ -1,21 +1,20 @@
/* /*
** Copyright 2006, The Android Open Source Project * Copyright 2006, The Android Open Source Project
** *
** Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
** You may obtain a copy of the License at * You may obtain a copy of the License at
** *
** http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
** *
** Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
** limitations under the License. * limitations under the License.
*/ */
#include <stddef.h> #include <stddef.h>
#include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
@ -30,17 +29,17 @@ void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
} }
void dump_registers(log_t* log, pid_t tid, int scope_flags) { void dump_registers(log_t* log, pid_t tid, int scope_flags) {
struct pt_regs r; struct pt_regs r;
if (ptrace(PTRACE_GETREGS, tid, 0, &r) == -1) { if (ptrace(PTRACE_GETREGS, tid, 0, &r) == -1) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno)); _LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return; return;
} }
_LOG(log, scope_flags, " eax %08lx ebx %08lx ecx %08lx edx %08lx\n", _LOG(log, scope_flags, " eax %08lx ebx %08lx ecx %08lx edx %08lx\n",
r.eax, r.ebx, r.ecx, r.edx); r.eax, r.ebx, r.ecx, r.edx);
_LOG(log, scope_flags, " esi %08lx edi %08lx\n", _LOG(log, scope_flags, " esi %08lx edi %08lx\n",
r.esi, r.edi); r.esi, r.edi);
_LOG(log, scope_flags, " xcs %08x xds %08x xes %08x xfs %08x xss %08x\n", _LOG(log, scope_flags, " xcs %08x xds %08x xes %08x xfs %08x xss %08x\n",
r.xcs, r.xds, r.xes, r.xfs, r.xss); r.xcs, r.xds, r.xes, r.xfs, r.xss);
_LOG(log, scope_flags, " eip %08lx ebp %08lx esp %08lx flags %08lx\n", _LOG(log, scope_flags, " eip %08lx ebp %08lx esp %08lx flags %08lx\n",
r.eip, r.ebp, r.esp, r.eflags); r.eip, r.ebp, r.esp, r.eflags);
} }

8
include/backtrace/Backtrace.h
View file

@ -60,6 +60,7 @@ public:
// Create a string representing the formatted line of backtrace information // Create a string representing the formatted line of backtrace information
// for a single frame. // for a single frame.
virtual std::string FormatFrameData(size_t frame_num); virtual std::string FormatFrameData(size_t frame_num);
virtual std::string FormatFrameData(const backtrace_frame_data_t* frame);
pid_t Pid() { return backtrace_.pid; } pid_t Pid() { return backtrace_.pid; }
pid_t Tid() { return backtrace_.tid; } pid_t Tid() { return backtrace_.tid; }
@ -68,9 +69,16 @@ public:
const backtrace_t* GetBacktrace() { return &backtrace_; } const backtrace_t* GetBacktrace() { return &backtrace_; }
const backtrace_frame_data_t* GetFrame(size_t frame_num) { const backtrace_frame_data_t* GetFrame(size_t frame_num) {
if (frame_num > NumFrames()) {
return NULL;
}
return &backtrace_.frames[frame_num]; return &backtrace_.frames[frame_num];
} }
const backtrace_map_info_t* GetMapList() {
return map_info_;
}
protected: protected:
Backtrace(BacktraceImpl* impl, pid_t pid, backtrace_map_info_t* map_info); Backtrace(BacktraceImpl* impl, pid_t pid, backtrace_map_info_t* map_info);

1
include/backtrace/backtrace.h
View file

@ -44,6 +44,7 @@ typedef struct backtrace_map_info {
} backtrace_map_info_t; } backtrace_map_info_t;
typedef struct { typedef struct {
size_t num; /* The current fame number. */
uintptr_t pc; /* The absolute pc. */ uintptr_t pc; /* The absolute pc. */
uintptr_t sp; /* The top of the stack. */ uintptr_t sp; /* The top of the stack. */
size_t stack_size; /* The size of the stack, zero indicate an unknown stack size. */ size_t stack_size; /* The size of the stack, zero indicate an unknown stack size. */

11
libbacktrace/Backtrace.cpp
View file

@ -125,7 +125,10 @@ const backtrace_map_info_t* Backtrace::FindMapInfo(uintptr_t ptr) {
} }
std::string Backtrace::FormatFrameData(size_t frame_num) { std::string Backtrace::FormatFrameData(size_t frame_num) {
backtrace_frame_data_t* frame = &backtrace_.frames[frame_num]; return FormatFrameData(&backtrace_.frames[frame_num]);
}
std::string Backtrace::FormatFrameData(const backtrace_frame_data_t* frame) {
const char* map_name; const char* map_name;
if (frame->map_name) { if (frame->map_name) {
map_name = frame->map_name; map_name = frame->map_name;
@ -142,13 +145,13 @@ std::string Backtrace::FormatFrameData(size_t frame_num) {
char buf[512]; char buf[512];
if (frame->func_name && frame->func_offset) { if (frame->func_name && frame->func_offset) {
snprintf(buf, sizeof(buf), "#%02zu pc %0*" PRIxPTR " %s (%s+%" PRIuPTR ")", snprintf(buf, sizeof(buf), "#%02zu pc %0*" PRIxPTR " %s (%s+%" PRIuPTR ")",
frame_num, (int)sizeof(uintptr_t)*2, relative_pc, map_name, frame->num, (int)sizeof(uintptr_t)*2, relative_pc, map_name,
frame->func_name, frame->func_offset); frame->func_name, frame->func_offset);
} else if (frame->func_name) { } else if (frame->func_name) {
snprintf(buf, sizeof(buf), "#%02zu pc %0*" PRIxPTR " %s (%s)", frame_num, snprintf(buf, sizeof(buf), "#%02zu pc %0*" PRIxPTR " %s (%s)", frame->num,
(int)sizeof(uintptr_t)*2, relative_pc, map_name, frame->func_name); (int)sizeof(uintptr_t)*2, relative_pc, map_name, frame->func_name);
} else { } else {
snprintf(buf, sizeof(buf), "#%02zu pc %0*" PRIxPTR " %s", frame_num, snprintf(buf, sizeof(buf), "#%02zu pc %0*" PRIxPTR " %s", frame->num,
(int)sizeof(uintptr_t)*2, relative_pc, map_name); (int)sizeof(uintptr_t)*2, relative_pc, map_name);
} }

2
libbacktrace/Corkscrew.cpp
View file

@ -45,6 +45,7 @@ bool CorkscrewCommon::GenerateFrameData(
data->num_frames = num_frames; data->num_frames = num_frames;
for (size_t i = 0; i < data->num_frames; i++) { for (size_t i = 0; i < data->num_frames; i++) {
backtrace_frame_data_t* frame = &data->frames[i]; backtrace_frame_data_t* frame = &data->frames[i];
frame->num = i;
frame->pc = cork_frames[i].absolute_pc; frame->pc = cork_frames[i].absolute_pc;
frame->sp = cork_frames[i].stack_top; frame->sp = cork_frames[i].stack_top;
frame->stack_size = cork_frames[i].stack_size; frame->stack_size = cork_frames[i].stack_size;
@ -146,6 +147,7 @@ void CorkscrewThread::ThreadUnwind(
data->num_frames = num_frames; data->num_frames = num_frames;
for (size_t i = 0; i < data->num_frames; i++) { for (size_t i = 0; i < data->num_frames; i++) {
backtrace_frame_data_t* frame = &data->frames[i]; backtrace_frame_data_t* frame = &data->frames[i];
frame->num = i;
frame->pc = frames[i].absolute_pc; frame->pc = frames[i].absolute_pc;
frame->sp = frames[i].stack_top; frame->sp = frames[i].stack_top;
frame->stack_size = frames[i].stack_size; frame->stack_size = frames[i].stack_size;

1
libbacktrace/UnwindCurrent.cpp
View file

@ -108,6 +108,7 @@ bool UnwindCurrent::UnwindFromContext(size_t num_ignore_frames, bool resolve) {
if (num_ignore_frames == 0) { if (num_ignore_frames == 0) {
size_t num_frames = backtrace->num_frames; size_t num_frames = backtrace->num_frames;
backtrace_frame_data_t* frame = &backtrace->frames[num_frames]; backtrace_frame_data_t* frame = &backtrace->frames[num_frames];
frame->num = num_frames;
frame->pc = static_cast<uintptr_t>(pc); frame->pc = static_cast<uintptr_t>(pc);
frame->sp = static_cast<uintptr_t>(sp); frame->sp = static_cast<uintptr_t>(sp);
frame->stack_size = 0; frame->stack_size = 0;

1
libbacktrace/UnwindPtrace.cpp
View file

@ -82,6 +82,7 @@ bool UnwindPtrace::Unwind(size_t num_ignore_frames) {
if (num_ignore_frames == 0) { if (num_ignore_frames == 0) {
size_t num_frames = backtrace->num_frames; size_t num_frames = backtrace->num_frames;
backtrace_frame_data_t* frame = &backtrace->frames[num_frames]; backtrace_frame_data_t* frame = &backtrace->frames[num_frames];
frame->num = num_frames;
frame->pc = static_cast<uintptr_t>(pc); frame->pc = static_cast<uintptr_t>(pc);
frame->sp = static_cast<uintptr_t>(sp); frame->sp = static_cast<uintptr_t>(sp);
frame->stack_size = 0; frame->stack_size = 0;

326
libbacktrace/backtrace_test.cpp
View file

@ -28,7 +28,8 @@
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <backtrace/backtrace.h> #include <backtrace/Backtrace.h>
#include <UniquePtr.h>
#include <cutils/atomic.h> #include <cutils/atomic.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
@ -57,7 +58,7 @@ typedef struct {
typedef struct { typedef struct {
thread_t thread; thread_t thread;
backtrace_context_t context; Backtrace* backtrace;
int32_t* now; int32_t* now;
int32_t done; int32_t done;
} dump_thread_t; } dump_thread_t;
@ -75,15 +76,14 @@ uint64_t NanoTime() {
return static_cast<uint64_t>(t.tv_sec * NS_PER_SEC + t.tv_nsec); return static_cast<uint64_t>(t.tv_sec * NS_PER_SEC + t.tv_nsec);
} }
void DumpFrames(const backtrace_context_t* context) { void DumpFrames(Backtrace* backtrace) {
if (context->backtrace->num_frames == 0) { if (backtrace->NumFrames() == 0) {
printf(" No frames to dump\n"); printf(" No frames to dump\n");
} else { return;
char line[512]; }
for (size_t i = 0; i < context->backtrace->num_frames; i++) {
backtrace_format_frame_data(context, i, line, sizeof(line)); for (size_t i = 0; i < backtrace->NumFrames(); i++) {
printf(" %s\n", line); printf(" %s\n", backtrace->FormatFrameData(i).c_str());
}
} }
} }
@ -100,12 +100,12 @@ void WaitForStop(pid_t pid) {
} }
} }
bool ReadyLevelBacktrace(const backtrace_t* backtrace) { bool ReadyLevelBacktrace(Backtrace* backtrace) {
// See if test_level_four is in the backtrace. // See if test_level_four is in the backtrace.
bool found = false; bool found = false;
for (size_t i = 0; i < backtrace->num_frames; i++) { for (size_t i = 0; i < backtrace->NumFrames(); i++) {
if (backtrace->frames[i].func_name != NULL && const backtrace_frame_data_t* frame = backtrace->GetFrame(i);
strcmp(backtrace->frames[i].func_name, "test_level_four") == 0) { if (frame->func_name != NULL && strcmp(frame->func_name, "test_level_four") == 0) {
found = true; found = true;
break; break;
} }
@ -114,64 +114,61 @@ bool ReadyLevelBacktrace(const backtrace_t* backtrace) {
return found; return found;
} }
void VerifyLevelDump(const backtrace_t* backtrace) { void VerifyLevelDump(Backtrace* backtrace) {
ASSERT_GT(backtrace->num_frames, static_cast<size_t>(0)); ASSERT_GT(backtrace->NumFrames(), static_cast<size_t>(0));
ASSERT_LT(backtrace->num_frames, static_cast<size_t>(MAX_BACKTRACE_FRAMES)); ASSERT_LT(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES));
// Look through the frames starting at the highest to find the // Look through the frames starting at the highest to find the
// frame we want. // frame we want.
size_t frame_num = 0; size_t frame_num = 0;
for (size_t i = backtrace->num_frames-1; i > 2; i--) { for (size_t i = backtrace->NumFrames()-1; i > 2; i--) {
if (backtrace->frames[i].func_name != NULL && if (backtrace->GetFrame(i)->func_name != NULL &&
strcmp(backtrace->frames[i].func_name, "test_level_one") == 0) { strcmp(backtrace->GetFrame(i)->func_name, "test_level_one") == 0) {
frame_num = i; frame_num = i;
break; break;
} }
} }
ASSERT_GT(frame_num, static_cast<size_t>(0)); ASSERT_LT(static_cast<size_t>(0), frame_num);
ASSERT_LE(static_cast<size_t>(3), frame_num);
ASSERT_TRUE(NULL != backtrace->frames[frame_num].func_name); ASSERT_TRUE(NULL != backtrace->GetFrame(frame_num)->func_name);
ASSERT_STREQ(backtrace->frames[frame_num].func_name, "test_level_one"); ASSERT_STREQ(backtrace->GetFrame(frame_num)->func_name, "test_level_one");
ASSERT_TRUE(NULL != backtrace->frames[frame_num-1].func_name); ASSERT_TRUE(NULL != backtrace->GetFrame(frame_num-1)->func_name);
ASSERT_STREQ(backtrace->frames[frame_num-1].func_name, "test_level_two"); ASSERT_STREQ(backtrace->GetFrame(frame_num-1)->func_name, "test_level_two");
ASSERT_TRUE(NULL != backtrace->frames[frame_num-2].func_name); ASSERT_TRUE(NULL != backtrace->GetFrame(frame_num-2)->func_name);
ASSERT_STREQ(backtrace->frames[frame_num-2].func_name, "test_level_three"); ASSERT_STREQ(backtrace->GetFrame(frame_num-2)->func_name, "test_level_three");
ASSERT_TRUE(NULL != backtrace->frames[frame_num-3].func_name); ASSERT_TRUE(NULL != backtrace->GetFrame(frame_num-3)->func_name);
ASSERT_STREQ(backtrace->frames[frame_num-3].func_name, "test_level_four"); ASSERT_STREQ(backtrace->GetFrame(frame_num-3)->func_name, "test_level_four");
} }
void VerifyLevelBacktrace(void*) { void VerifyLevelBacktrace(void*) {
backtrace_context_t context; UniquePtr<Backtrace> backtrace(
Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
ASSERT_TRUE(backtrace_create_context(&context, BACKTRACE_CURRENT_PROCESS, VerifyLevelDump(backtrace.get());
BACKTRACE_CURRENT_THREAD, 0));
VerifyLevelDump(context.backtrace);
backtrace_destroy_context(&context);
} }
bool ReadyMaxBacktrace(const backtrace_t* backtrace) { bool ReadyMaxBacktrace(Backtrace* backtrace) {
return (backtrace->num_frames == MAX_BACKTRACE_FRAMES); return (backtrace->NumFrames() == MAX_BACKTRACE_FRAMES);
} }
void VerifyMaxDump(const backtrace_t* backtrace) { void VerifyMaxDump(Backtrace* backtrace) {
ASSERT_EQ(backtrace->num_frames, static_cast<size_t>(MAX_BACKTRACE_FRAMES)); ASSERT_EQ(backtrace->NumFrames(), static_cast<size_t>(MAX_BACKTRACE_FRAMES));
// Verify that the last frame is our recursive call. // Verify that the last frame is our recursive call.
ASSERT_TRUE(NULL != backtrace->frames[MAX_BACKTRACE_FRAMES-1].func_name); ASSERT_TRUE(NULL != backtrace->GetFrame(MAX_BACKTRACE_FRAMES-1)->func_name);
ASSERT_STREQ(backtrace->frames[MAX_BACKTRACE_FRAMES-1].func_name, ASSERT_STREQ(backtrace->GetFrame(MAX_BACKTRACE_FRAMES-1)->func_name,
"test_recursive_call"); "test_recursive_call");
} }
void VerifyMaxBacktrace(void*) { void VerifyMaxBacktrace(void*) {
backtrace_context_t context; UniquePtr<Backtrace> backtrace(
Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
ASSERT_TRUE(backtrace_create_context(&context, BACKTRACE_CURRENT_PROCESS, VerifyMaxDump(backtrace.get());
BACKTRACE_CURRENT_THREAD, 0));
VerifyMaxDump(context.backtrace);
backtrace_destroy_context(&context);
} }
void ThreadSetState(void* data) { void ThreadSetState(void* data) {
@ -183,14 +180,12 @@ void ThreadSetState(void* data) {
} }
} }
void VerifyThreadTest(pid_t tid, void (*VerifyFunc)(const backtrace_t*)) { void VerifyThreadTest(pid_t tid, void (*VerifyFunc)(Backtrace*)) {
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), tid));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
backtrace_create_context(&context, getpid(), tid, 0); VerifyFunc(backtrace.get());
VerifyFunc(context.backtrace);
backtrace_destroy_context(&context);
} }
bool WaitForNonZero(int32_t* value, uint64_t seconds) { bool WaitForNonZero(int32_t* value, uint64_t seconds) {
@ -208,52 +203,47 @@ TEST(libbacktrace, local_trace) {
} }
void VerifyIgnoreFrames( void VerifyIgnoreFrames(
const backtrace_t* bt_all, const backtrace_t* bt_ign1, Backtrace* bt_all, Backtrace* bt_ign1,
const backtrace_t* bt_ign2, const char* cur_proc) { Backtrace* bt_ign2, const char* cur_proc) {
EXPECT_EQ(bt_all->num_frames, bt_ign1->num_frames + 1); EXPECT_EQ(bt_all->NumFrames(), bt_ign1->NumFrames() + 1);
EXPECT_EQ(bt_all->num_frames, bt_ign2->num_frames + 2); EXPECT_EQ(bt_all->NumFrames(), bt_ign2->NumFrames() + 2);
// Check all of the frames are the same > the current frame. // Check all of the frames are the same > the current frame.
bool check = (cur_proc == NULL); bool check = (cur_proc == NULL);
for (size_t i = 0; i < bt_ign2->num_frames; i++) { for (size_t i = 0; i < bt_ign2->NumFrames(); i++) {
if (check) { if (check) {
EXPECT_EQ(bt_ign2->frames[i].pc, bt_ign1->frames[i+1].pc); EXPECT_EQ(bt_ign2->GetFrame(i)->pc, bt_ign1->GetFrame(i+1)->pc);
EXPECT_EQ(bt_ign2->frames[i].sp, bt_ign1->frames[i+1].sp); EXPECT_EQ(bt_ign2->GetFrame(i)->sp, bt_ign1->GetFrame(i+1)->sp);
EXPECT_EQ(bt_ign2->frames[i].stack_size, bt_ign1->frames[i+1].stack_size); EXPECT_EQ(bt_ign2->GetFrame(i)->stack_size, bt_ign1->GetFrame(i+1)->stack_size);
EXPECT_EQ(bt_ign2->frames[i].pc, bt_all->frames[i+2].pc); EXPECT_EQ(bt_ign2->GetFrame(i)->pc, bt_all->GetFrame(i+2)->pc);
EXPECT_EQ(bt_ign2->frames[i].sp, bt_all->frames[i+2].sp); EXPECT_EQ(bt_ign2->GetFrame(i)->sp, bt_all->GetFrame(i+2)->sp);
EXPECT_EQ(bt_ign2->frames[i].stack_size, bt_all->frames[i+2].stack_size); EXPECT_EQ(bt_ign2->GetFrame(i)->stack_size, bt_all->GetFrame(i+2)->stack_size);
} }
if (!check && bt_ign2->frames[i].func_name && if (!check && bt_ign2->GetFrame(i)->func_name &&
strcmp(bt_ign2->frames[i].func_name, cur_proc) == 0) { strcmp(bt_ign2->GetFrame(i)->func_name, cur_proc) == 0) {
check = true; check = true;
} }
} }
} }
void VerifyLevelIgnoreFrames(void*) { void VerifyLevelIgnoreFrames(void*) {
backtrace_context_t all; UniquePtr<Backtrace> all(
ASSERT_TRUE(backtrace_create_context(&all, BACKTRACE_CURRENT_PROCESS, Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
BACKTRACE_CURRENT_THREAD, 0)); ASSERT_TRUE(all.get() != NULL);
ASSERT_TRUE(all.backtrace != NULL); ASSERT_TRUE(all->Unwind(0));
backtrace_context_t ign1; UniquePtr<Backtrace> ign1(
ASSERT_TRUE(backtrace_create_context(&ign1, BACKTRACE_CURRENT_PROCESS, Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
BACKTRACE_CURRENT_THREAD, 1)); ASSERT_TRUE(ign1.get() != NULL);
ASSERT_TRUE(ign1.backtrace != NULL); ASSERT_TRUE(ign1->Unwind(1));
backtrace_context_t ign2; UniquePtr<Backtrace> ign2(
ASSERT_TRUE(backtrace_create_context(&ign2, BACKTRACE_CURRENT_PROCESS, Backtrace::Create(BACKTRACE_CURRENT_PROCESS, BACKTRACE_CURRENT_THREAD));
BACKTRACE_CURRENT_THREAD, 2)); ASSERT_TRUE(ign2.get() != NULL);
ASSERT_TRUE(ign2.backtrace != NULL); ASSERT_TRUE(ign2->Unwind(2));
VerifyIgnoreFrames(all.backtrace, ign1.backtrace, ign2.backtrace, VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), "VerifyLevelIgnoreFrames");
"VerifyLevelIgnoreFrames");
backtrace_destroy_context(&all);
backtrace_destroy_context(&ign1);
backtrace_destroy_context(&ign2);
} }
TEST(libbacktrace, local_trace_ignore_frames) { TEST(libbacktrace, local_trace_ignore_frames) {
@ -265,8 +255,8 @@ TEST(libbacktrace, local_max_trace) {
} }
void VerifyProcTest(pid_t pid, pid_t tid, void VerifyProcTest(pid_t pid, pid_t tid,
bool (*ReadyFunc)(const backtrace_t*), bool (*ReadyFunc)(Backtrace*),
void (*VerifyFunc)(const backtrace_t*)) { void (*VerifyFunc)(Backtrace*)) {
pid_t ptrace_tid; pid_t ptrace_tid;
if (tid < 0) { if (tid < 0) {
ptrace_tid = pid; ptrace_tid = pid;
@ -281,13 +271,14 @@ void VerifyProcTest(pid_t pid, pid_t tid,
// Wait for the process to get to a stopping point. // Wait for the process to get to a stopping point.
WaitForStop(ptrace_tid); WaitForStop(ptrace_tid);
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(pid, tid));
ASSERT_TRUE(backtrace_create_context(&context, pid, tid, 0)); ASSERT_TRUE(backtrace->Unwind(0));
if (ReadyFunc(context.backtrace)) { ASSERT_TRUE(backtrace.get() != NULL);
VerifyFunc(context.backtrace); if (ReadyFunc(backtrace.get())) {
VerifyFunc(backtrace.get());
verified = true; verified = true;
} }
backtrace_destroy_context(&context);
ASSERT_TRUE(ptrace(PTRACE_DETACH, ptrace_tid, 0, 0) == 0); ASSERT_TRUE(ptrace(PTRACE_DETACH, ptrace_tid, 0, 0) == 0);
} }
// If 5 seconds have passed, then we are done. // If 5 seconds have passed, then we are done.
@ -321,21 +312,16 @@ TEST(libbacktrace, ptrace_max_trace) {
ASSERT_EQ(waitpid(pid, &status, 0), pid); ASSERT_EQ(waitpid(pid, &status, 0), pid);
} }
void VerifyProcessIgnoreFrames(const backtrace_t* bt_all) { void VerifyProcessIgnoreFrames(Backtrace* bt_all) {
pid_t pid = bt_all->pid; UniquePtr<Backtrace> ign1(Backtrace::Create(bt_all->Pid(), BACKTRACE_CURRENT_THREAD));
ASSERT_TRUE(ign1.get() != NULL);
ASSERT_TRUE(ign1->Unwind(1));
backtrace_context_t ign1; UniquePtr<Backtrace> ign2(Backtrace::Create(bt_all->Pid(), BACKTRACE_CURRENT_THREAD));
ASSERT_TRUE(backtrace_create_context(&ign1, pid, BACKTRACE_CURRENT_THREAD, 1)); ASSERT_TRUE(ign2.get() != NULL);
ASSERT_TRUE(ign1.backtrace != NULL); ASSERT_TRUE(ign2->Unwind(2));
backtrace_context_t ign2; VerifyIgnoreFrames(bt_all, ign1.get(), ign2.get(), NULL);
ASSERT_TRUE(backtrace_create_context(&ign2, pid, BACKTRACE_CURRENT_THREAD, 2));
ASSERT_TRUE(ign2.backtrace != NULL);
VerifyIgnoreFrames(bt_all, ign1.backtrace, ign2.backtrace, NULL);
backtrace_destroy_context(&ign1);
backtrace_destroy_context(&ign2);
} }
TEST(libbacktrace, ptrace_ignore_frames) { TEST(libbacktrace, ptrace_ignore_frames) {
@ -418,13 +404,11 @@ TEST(libbacktrace, ptrace_threads) {
} }
void VerifyLevelThread(void*) { void VerifyLevelThread(void*) {
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
ASSERT_TRUE(backtrace_create_context(&context, getpid(), gettid(), 0)); VerifyLevelDump(backtrace.get());
VerifyLevelDump(context.backtrace);
backtrace_destroy_context(&context);
} }
TEST(libbacktrace, thread_current_level) { TEST(libbacktrace, thread_current_level) {
@ -432,13 +416,11 @@ TEST(libbacktrace, thread_current_level) {
} }
void VerifyMaxThread(void*) { void VerifyMaxThread(void*) {
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), gettid()));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
ASSERT_TRUE(backtrace_create_context(&context, getpid(), gettid(), 0)); VerifyMaxDump(backtrace.get());
VerifyMaxDump(context.backtrace);
backtrace_destroy_context(&context);
} }
TEST(libbacktrace, thread_current_max) { TEST(libbacktrace, thread_current_max) {
@ -469,13 +451,11 @@ TEST(libbacktrace, thread_level_trace) {
struct sigaction cur_action; struct sigaction cur_action;
ASSERT_TRUE(sigaction(SIGURG, NULL, &cur_action) == 0); ASSERT_TRUE(sigaction(SIGURG, NULL, &cur_action) == 0);
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
ASSERT_TRUE(backtrace_create_context(&context, getpid(), thread_data.tid,0)); VerifyLevelDump(backtrace.get());
VerifyLevelDump(context.backtrace);
backtrace_destroy_context(&context);
// Tell the thread to exit its infinite loop. // Tell the thread to exit its infinite loop.
android_atomic_acquire_store(0, &thread_data.state); android_atomic_acquire_store(0, &thread_data.state);
@ -499,20 +479,19 @@ TEST(libbacktrace, thread_ignore_frames) {
// Wait up to 2 seconds for the tid to be set. // Wait up to 2 seconds for the tid to be set.
ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2)); ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
backtrace_context_t all; UniquePtr<Backtrace> all(Backtrace::Create(getpid(), thread_data.tid));
ASSERT_TRUE(backtrace_create_context(&all, getpid(), thread_data.tid, 0)); ASSERT_TRUE(all.get() != NULL);
ASSERT_TRUE(all->Unwind(0));
backtrace_context_t ign1; UniquePtr<Backtrace> ign1(Backtrace::Create(getpid(), thread_data.tid));
ASSERT_TRUE(backtrace_create_context(&ign1, getpid(), thread_data.tid, 1)); ASSERT_TRUE(ign1.get() != NULL);
ASSERT_TRUE(ign1->Unwind(1));
backtrace_context_t ign2; UniquePtr<Backtrace> ign2(Backtrace::Create(getpid(), thread_data.tid));
ASSERT_TRUE(backtrace_create_context(&ign2, getpid(), thread_data.tid, 2)); ASSERT_TRUE(ign2.get() != NULL);
ASSERT_TRUE(ign2->Unwind(2));
VerifyIgnoreFrames(all.backtrace, ign1.backtrace, ign2.backtrace, NULL); VerifyIgnoreFrames(all.get(), ign1.get(), ign2.get(), NULL);
backtrace_destroy_context(&all);
backtrace_destroy_context(&ign1);
backtrace_destroy_context(&ign2);
// Tell the thread to exit its infinite loop. // Tell the thread to exit its infinite loop.
android_atomic_acquire_store(0, &thread_data.state); android_atomic_acquire_store(0, &thread_data.state);
@ -538,13 +517,11 @@ TEST(libbacktrace, thread_max_trace) {
// Wait for the tid to be set. // Wait for the tid to be set.
ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2)); ASSERT_TRUE(WaitForNonZero(&thread_data.state, 2));
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), thread_data.tid));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace->Unwind(0));
ASSERT_TRUE(backtrace_create_context(&context, getpid(), thread_data.tid, 0)); VerifyMaxDump(backtrace.get());
VerifyMaxDump(context.backtrace);
backtrace_destroy_context(&context);
// Tell the thread to exit its infinite loop. // Tell the thread to exit its infinite loop.
android_atomic_acquire_store(0, &thread_data.state); android_atomic_acquire_store(0, &thread_data.state);
@ -558,11 +535,9 @@ void* ThreadDump(void* data) {
} }
} }
dump->context.data = NULL;
dump->context.backtrace = NULL;
// The status of the actual unwind will be checked elsewhere. // The status of the actual unwind will be checked elsewhere.
backtrace_create_context(&dump->context, getpid(), dump->thread.tid, 0); dump->backtrace = Backtrace::Create(getpid(), dump->thread.tid);
dump->backtrace->Unwind(0);
android_atomic_acquire_store(1, &dump->done); android_atomic_acquire_store(1, &dump->done);
@ -610,58 +585,51 @@ TEST(libbacktrace, thread_multiple_dump) {
// Tell the runner thread to exit its infinite loop. // Tell the runner thread to exit its infinite loop.
android_atomic_acquire_store(0, &runners[i].state); android_atomic_acquire_store(0, &runners[i].state);
ASSERT_TRUE(dumpers[i].context.backtrace != NULL); ASSERT_TRUE(dumpers[i].backtrace != NULL);
VerifyMaxDump(dumpers[i].context.backtrace); VerifyMaxDump(dumpers[i].backtrace);
backtrace_destroy_context(&dumpers[i].context);
delete dumpers[i].backtrace;
dumpers[i].backtrace = NULL;
} }
} }
TEST(libbacktrace, format_test) { TEST(libbacktrace, format_test) {
backtrace_context_t context; UniquePtr<Backtrace> backtrace(Backtrace::Create(getpid(), BACKTRACE_CURRENT_THREAD));
ASSERT_TRUE(backtrace.get() != NULL);
ASSERT_TRUE(backtrace_create_context(&context, BACKTRACE_CURRENT_PROCESS, backtrace_frame_data_t frame;
BACKTRACE_CURRENT_THREAD, 0)); memset(&frame, 0, sizeof(backtrace_frame_data_t));
ASSERT_TRUE(context.backtrace != NULL);
backtrace_frame_data_t* frame = frame.num = 1;
const_cast<backtrace_frame_data_t*>(&context.backtrace->frames[1]);
backtrace_frame_data_t save_frame = *frame;
memset(frame, 0, sizeof(backtrace_frame_data_t));
char buf[512];
backtrace_format_frame_data(&context, 1, buf, sizeof(buf));
#if defined(__LP64__) #if defined(__LP64__)
EXPECT_STREQ(buf, "#01 pc 0000000000000000 <unknown>"); EXPECT_STREQ("#01 pc 0000000000000000 <unknown>",
#else #else
EXPECT_STREQ(buf, "#01 pc 00000000 <unknown>"); EXPECT_STREQ("#01 pc 00000000 <unknown>",
#endif #endif
backtrace->FormatFrameData(&frame).c_str());
frame->pc = 0x12345678; frame.pc = 0x12345678;
frame->map_name = "MapFake"; frame.map_name = "MapFake";
backtrace_format_frame_data(&context, 1, buf, sizeof(buf));
#if defined(__LP64__) #if defined(__LP64__)
EXPECT_STREQ(buf, "#01 pc 0000000012345678 MapFake"); EXPECT_STREQ("#01 pc 0000000012345678 MapFake",
#else #else
EXPECT_STREQ(buf, "#01 pc 12345678 MapFake"); EXPECT_STREQ("#01 pc 12345678 MapFake",
#endif #endif
backtrace->FormatFrameData(&frame).c_str());
frame->func_name = const_cast<char*>("ProcFake"); frame.func_name = const_cast<char*>("ProcFake");
backtrace_format_frame_data(&context, 1, buf, sizeof(buf));
#if defined(__LP64__) #if defined(__LP64__)
EXPECT_STREQ(buf, "#01 pc 0000000012345678 MapFake (ProcFake)"); EXPECT_STREQ("#01 pc 0000000012345678 MapFake (ProcFake)",
#else #else
EXPECT_STREQ(buf, "#01 pc 12345678 MapFake (ProcFake)"); EXPECT_STREQ("#01 pc 12345678 MapFake (ProcFake)",
#endif #endif
backtrace->FormatFrameData(&frame).c_str());
frame->func_offset = 645; frame.func_offset = 645;
backtrace_format_frame_data(&context, 1, buf, sizeof(buf));
#if defined(__LP64__) #if defined(__LP64__)
EXPECT_STREQ(buf, "#01 pc 0000000012345678 MapFake (ProcFake+645)"); EXPECT_STREQ("#01 pc 0000000012345678 MapFake (ProcFake+645)",
#else #else
EXPECT_STREQ(buf, "#01 pc 12345678 MapFake (ProcFake+645)"); EXPECT_STREQ("#01 pc 12345678 MapFake (ProcFake+645)",
#endif #endif
backtrace->FormatFrameData(&frame).c_str());
*frame = save_frame;
backtrace_destroy_context(&context);
} }