tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
* commit '1f71e465ef1544a2962299445dee03e6856ea54a':
  Next phase of the move, reformat use C++ features.
This commit is contained in:
Christopher Ferris 2014-01-14 01:26:26 +00:00 committed by Android Git Automerger
commit 50fae736dc
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
**
** 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.
*/
/*
*
* Copyright 2006, 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 <errno.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
@ -28,7 +27,7 @@
#include "../utility.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
#ifdef WITH_VFP
@ -40,140 +39,134 @@
#endif
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 ascii_buffer[32]; /* actual 16 + 1 == 17 */
uintptr_t p, end;
char code_buffer[64]; // actual 8+1+((8+1)*4) + 1 == 45
char ascii_buffer[32]; // actual 16 + 1 == 17
uintptr_t p, end;
p = addr & ~3;
p -= 32;
if (p > addr) {
/* catch underflow */
p = 0;
}
/* Dump more memory content for the crashing thread. */
end = p + 256;
/* catch overflow; 'end - p' has to be multiples of 16 */
while (end < p)
end -= 16;
p = addr & ~3;
p -= 32;
if (p > addr) {
// catch underflow
p = 0;
}
// Dump more memory content for the crashing thread.
end = p + 256;
// catch overflow; 'end - p' has to be multiples of 16
while (end < p)
end -= 16;
/* Dump the code around PC as:
* addr contents ascii
* 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q
* 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p......
*/
while (p < end) {
char* asc_out = ascii_buffer;
// Dump the code around PC as:
// addr contents ascii
// 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q
// 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p......
while (p < end) {
char* asc_out = ascii_buffer;
sprintf(code_buffer, "%08x ", p);
sprintf(code_buffer, "%08x ", p);
int i;
for (i = 0; i < 4; i++) {
/*
* If we see (data == -1 && errno != 0), we know that the ptrace
* call failed, probably because we're dumping memory in an
* unmapped or inaccessible page. I don't know if there's
* value in making that explicit in the output -- it likely
* just complicates parsing and clarifies nothing for the
* enlightened reader.
*/
long data = ptrace(PTRACE_PEEKTEXT, tid, (void*)p, NULL);
sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
int i;
for (i = 0; i < 4; i++) {
// If we see (data == -1 && errno != 0), we know that the ptrace
// call failed, probably because we're dumping memory in an
// unmapped or inaccessible page. I don't know if there's
// value in making that explicit in the output -- it likely
// just complicates parsing and clarifies nothing for the
// enlightened reader.
long data = ptrace(PTRACE_PEEKTEXT, tid, reinterpret_cast<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
int j;
for (j = 0; j < 4; j++) {
/*
* Our isprint() allows high-ASCII characters that display
* differently (often badly) in different viewers, so we
* just use a simpler test.
*/
char val = (data >> (j*8)) & 0xff;
if (val >= 0x20 && val < 0x7f) {
*asc_out++ = val;
} else {
*asc_out++ = '.';
}
}
int j;
for (j = 0; j < 4; j++) {
// Our isprint() allows high-ASCII characters that display
// differently (often badly) in different viewers, so we
// just use a simpler test.
char val = (data >> (j*8)) & 0xff;
if (val >= 0x20 && val < 0x7f) {
*asc_out++ = val;
} else {
*asc_out++ = '.';
}
}
#endif
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
* for the crashing thread.
*/
// If configured to do so, dump memory around *all* registers
// for the crashing thread.
void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
struct pt_regs regs;
if(ptrace(PTRACE_GETREGS, tid, 0, &regs)) {
return;
struct pt_regs regs;
if (ptrace(PTRACE_GETREGS, tid, 0, &regs)) {
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) {
static const char REG_NAMES[] = "r0r1r2r3r4r5r6r7r8r9slfpipsp";
// explicitly allow upload of code dump logging
_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++) {
/* 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);
}
}
/* 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);
}
if (regs.ARM_pc != regs.ARM_lr) {
_LOG(log, scope_flags, "\ncode around lr:\n");
dump_memory(log, tid, static_cast<uintptr_t>(regs.ARM_lr), scope_flags);
}
}
void dump_registers(log_t* log, pid_t tid, int scope_flags)
{
struct pt_regs r;
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
void dump_registers(log_t* log, pid_t tid, int scope_flags) {
struct pt_regs r;
if (ptrace(PTRACE_GETREGS, tid, 0, &r)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
_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);
_LOG(log, scope_flags, " r4 %08x r5 %08x r6 %08x r7 %08x\n",
(uint32_t)r.ARM_r4, (uint32_t)r.ARM_r5, (uint32_t)r.ARM_r6, (uint32_t)r.ARM_r7);
_LOG(log, scope_flags, " r8 %08x r9 %08x sl %08x fp %08x\n",
(uint32_t)r.ARM_r8, (uint32_t)r.ARM_r9, (uint32_t)r.ARM_r10, (uint32_t)r.ARM_fp);
_LOG(log, scope_flags, " ip %08x sp %08x lr %08x pc %08x cpsr %08x\n",
(uint32_t)r.ARM_ip, (uint32_t)r.ARM_sp, (uint32_t)r.ARM_lr,
(uint32_t)r.ARM_pc, (uint32_t)r.ARM_cpsr);
_LOG(log, scope_flags, " r0 %08x r1 %08x r2 %08x r3 %08x\n",
static_cast<uint32_t>(r.ARM_r0), static_cast<uint32_t>(r.ARM_r1),
static_cast<uint32_t>(r.ARM_r2), static_cast<uint32_t>(r.ARM_r3));
_LOG(log, scope_flags, " r4 %08x r5 %08x r6 %08x r7 %08x\n",
static_cast<uint32_t>(r.ARM_r4), static_cast<uint32_t>(r.ARM_r5),
static_cast<uint32_t>(r.ARM_r6), static_cast<uint32_t>(r.ARM_r7));
_LOG(log, scope_flags, " r8 %08x r9 %08x sl %08x fp %08x\n",
static_cast<uint32_t>(r.ARM_r8), static_cast<uint32_t>(r.ARM_r9),
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
struct user_vfp vfp_regs;
int i;
struct user_vfp vfp_regs;
int i;
if(ptrace(PTRACE_GETVFPREGS, tid, 0, &vfp_regs)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
if (ptrace(PTRACE_GETVFPREGS, tid, 0, &vfp_regs)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
for (i = 0; i < NUM_VFP_REGS; i += 2) {
_LOG(log, scope_flags, " d%-2d %016llx d%-2d %016llx\n",
i, vfp_regs.fpregs[i], i+1, vfp_regs.fpregs[i+1]);
}
_LOG(log, scope_flags, " scr %08lx\n", vfp_regs.fpscr);
for (i = 0; i < NUM_VFP_REGS; i += 2) {
_LOG(log, scope_flags, " d%-2d %016llx d%-2d %016llx\n",
i, vfp_regs.fpregs[i], i+1, vfp_regs.fpregs[i+1]);
}
_LOG(log, scope_flags, " scr %08lx\n", vfp_regs.fpscr);
#endif
}

166
debuggerd/backtrace.cpp
View file

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

16
debuggerd/backtrace.h
View file

@ -17,21 +17,19 @@
#ifndef _DEBUGGERD_BACKTRACE_H
#define _DEBUGGERD_BACKTRACE_H
#include <stddef.h>
#include <stdbool.h>
#include <sys/types.h>
#include <backtrace/backtrace.h>
#include "utility.h"
/* Dumps a backtrace using a format similar to what Dalvik uses so that the result
* can be intermixed in a bug report. */
class Backtrace;
// 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,
int* total_sleep_time_usec);
int* total_sleep_time_usec);
/* Dumps the backtrace in the backtrace data structure to the log. */
void dump_backtrace_to_log(const backtrace_context_t* context, log_t* log,
int scope_flags, const char* prefix);
void dump_backtrace_to_log(Backtrace* backtrace, log_t* log,
int scope_flags, const char* prefix);
#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
**
** 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.
*/
/*
* Copyright 2006, 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 <errno.h>
@ -38,8 +37,6 @@
#include <cutils/properties.h>
#include <cutils/debugger.h>
#include <corkscrew/backtrace.h>
#include <linux/input.h>
#include <private/android_filesystem_config.h>
@ -50,490 +47,468 @@
#include "utility.h"
typedef struct {
debugger_action_t action;
pid_t pid, tid;
uid_t uid, gid;
uintptr_t abort_msg_address;
debugger_action_t action;
pid_t pid, tid;
uid_t uid, gid;
uintptr_t abort_msg_address;
} debugger_request_t;
static int
write_string(const char* file, const char* string)
{
int len;
int fd;
ssize_t amt;
fd = open(file, O_RDWR);
len = strlen(string);
if (fd < 0)
return -errno;
amt = write(fd, string, len);
close(fd);
return amt >= 0 ? 0 : -errno;
static int write_string(const char* file, const char* string) {
int len;
int fd;
ssize_t amt;
fd = open(file, O_RDWR);
len = strlen(string);
if (fd < 0)
return -errno;
amt = write(fd, string, len);
close(fd);
return amt >= 0 ? 0 : -errno;
}
static
void init_debug_led(void)
{
// trout leds
write_string("/sys/class/leds/red/brightness", "0");
write_string("/sys/class/leds/green/brightness", "0");
write_string("/sys/class/leds/blue/brightness", "0");
write_string("/sys/class/leds/red/device/blink", "0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "0,0");
static void init_debug_led() {
// trout leds
write_string("/sys/class/leds/red/brightness", "0");
write_string("/sys/class/leds/green/brightness", "0");
write_string("/sys/class/leds/blue/brightness", "0");
write_string("/sys/class/leds/red/device/blink", "0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "0,0");
}
static
void enable_debug_led(void)
{
// trout leds
write_string("/sys/class/leds/red/brightness", "255");
// sardine leds
write_string("/sys/class/leds/left/cadence", "1,0");
static void enable_debug_led() {
// trout leds
write_string("/sys/class/leds/red/brightness", "255");
// sardine leds
write_string("/sys/class/leds/left/cadence", "1,0");
}
static
void disable_debug_led(void)
{
// trout leds
write_string("/sys/class/leds/red/brightness", "0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "0,0");
static void disable_debug_led() {
// trout leds
write_string("/sys/class/leds/red/brightness", "0");
// sardine leds
write_string("/sys/class/leds/left/cadence", "0,0");
}
static void wait_for_user_action(pid_t pid) {
/* First log a helpful message */
LOG( "********************************************************\n"
"* Process %d has been suspended while crashing. To\n"
"* attach gdbserver for a gdb connection on port 5039\n"
"* and start gdbclient:\n"
"*\n"
"* gdbclient app_process :5039 %d\n"
"*\n"
"* Wait for gdb to start, then press HOME or VOLUME DOWN key\n"
"* to let the process continue crashing.\n"
"********************************************************\n",
pid, pid);
// First log a helpful message
LOG( "********************************************************\n"
"* Process %d has been suspended while crashing. To\n"
"* attach gdbserver for a gdb connection on port 5039\n"
"* and start gdbclient:\n"
"*\n"
"* gdbclient app_process :5039 %d\n"
"*\n"
"* Wait for gdb to start, then press HOME or VOLUME DOWN key\n"
"* to let the process continue crashing.\n"
"********************************************************\n",
pid, pid);
/* wait for HOME or VOLUME DOWN key */
if (init_getevent() == 0) {
int ms = 1200 / 10;
int dit = 1;
int dah = 3*dit;
int _ = -dit;
int ___ = 3*_;
int _______ = 7*_;
const int codes[] = {
dit,_,dit,_,dit,___,dah,_,dah,_,dah,___,dit,_,dit,_,dit,_______
};
size_t s = 0;
struct input_event e;
bool done = false;
init_debug_led();
enable_debug_led();
do {
int timeout = abs(codes[s]) * ms;
int res = get_event(&e, timeout);
if (res == 0) {
if (e.type == EV_KEY
&& (e.code == KEY_HOME || e.code == KEY_VOLUMEDOWN)
&& e.value == 0) {
done = true;
}
} else if (res == 1) {
if (++s >= sizeof(codes)/sizeof(*codes))
s = 0;
if (codes[s] > 0) {
enable_debug_led();
} else {
disable_debug_led();
}
}
} while (!done);
uninit_getevent();
}
// wait for HOME or VOLUME DOWN key
if (init_getevent() == 0) {
int ms = 1200 / 10;
int dit = 1;
int dah = 3*dit;
int _ = -dit;
int ___ = 3*_;
int _______ = 7*_;
const int codes[] = {
dit,_,dit,_,dit,___,dah,_,dah,_,dah,___,dit,_,dit,_,dit,_______
};
size_t s = 0;
struct input_event e;
bool done = false;
init_debug_led();
enable_debug_led();
do {
int timeout = abs(codes[s]) * ms;
int res = get_event(&e, timeout);
if (res == 0) {
if (e.type == EV_KEY
&& (e.code == KEY_HOME || e.code == KEY_VOLUMEDOWN)
&& e.value == 0) {
done = true;
}
} else if (res == 1) {
if (++s >= sizeof(codes)/sizeof(*codes))
s = 0;
if (codes[s] > 0) {
enable_debug_led();
} else {
disable_debug_led();
}
}
} while (!done);
uninit_getevent();
}
/* don't forget to turn debug led off */
disable_debug_led();
LOG("debuggerd resuming process %d", pid);
// don't forget to turn debug led off
disable_debug_led();
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) {
char path[64];
snprintf(path, sizeof(path), "/proc/%d/status", tid);
char path[64];
snprintf(path, sizeof(path), "/proc/%d/status", tid);
FILE* fp = fopen(path, "r");
if (!fp) {
return -1;
}
FILE* fp = fopen(path, "r");
if (!fp) {
return -1;
}
int fields = 0;
char line[1024];
while (fgets(line, sizeof(line), fp)) {
size_t len = strlen(line);
if (len > 6 && !memcmp(line, "Tgid:\t", 6)) {
*out_pid = atoi(line + 6);
fields |= 1;
} else if (len > 5 && !memcmp(line, "Uid:\t", 5)) {
*out_uid = atoi(line + 5);
fields |= 2;
} else if (len > 5 && !memcmp(line, "Gid:\t", 5)) {
*out_gid = atoi(line + 5);
fields |= 4;
}
int fields = 0;
char line[1024];
while (fgets(line, sizeof(line), fp)) {
size_t len = strlen(line);
if (len > 6 && !memcmp(line, "Tgid:\t", 6)) {
*out_pid = atoi(line + 6);
fields |= 1;
} else if (len > 5 && !memcmp(line, "Uid:\t", 5)) {
*out_uid = atoi(line + 5);
fields |= 2;
} else if (len > 5 && !memcmp(line, "Gid:\t", 5)) {
*out_gid = atoi(line + 5);
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) {
struct ucred cr;
int len = sizeof(cr);
int status = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
if (status != 0) {
LOG("cannot get credentials\n");
return -1;
struct ucred cr;
int len = sizeof(cr);
int status = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
if (status != 0) {
LOG("cannot get credentials\n");
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;
}
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
} else if (cr.uid == 0
|| (cr.uid == AID_SYSTEM && msg.action == DEBUGGER_ACTION_DUMP_BACKTRACE)) {
/* Only root or system can ask us to attach to any process and dump it explicitly.
* However, system is only allowed to collect backtraces but cannot dump tombstones. */
status = get_process_info(out_request->tid, &out_request->pid,
&out_request->uid, &out_request->gid);
if (status < 0) {
LOG("tid %d does not exist. ignoring explicit dump request\n",
out_request->tid);
return -1;
}
} else {
/* No one else is allowed to dump arbitrary processes. */
return -1;
// Only root or system can ask us to attach to any process and dump it explicitly.
// However, system is only allowed to collect backtraces but cannot dump tombstones.
status = get_process_info(out_request->tid, &out_request->pid,
&out_request->uid, &out_request->gid);
if (status < 0) {
LOG("tid %d does not exist. ignoring explicit dump request\n", out_request->tid);
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) {
if (request->action == DEBUGGER_ACTION_CRASH) {
char value[PROPERTY_VALUE_MAX];
property_get("debug.db.uid", value, "-1");
int debug_uid = atoi(value);
return debug_uid >= 0 && request->uid <= (uid_t)debug_uid;
}
return false;
if (request->action == DEBUGGER_ACTION_CRASH) {
char value[PROPERTY_VALUE_MAX];
property_get("debug.db.uid", value, "-1");
int debug_uid = atoi(value);
return debug_uid >= 0 && request->uid <= (uid_t)debug_uid;
}
return false;
}
static void handle_request(int fd) {
XLOG("handle_request(%d)\n", fd);
XLOG("handle_request(%d)\n", fd);
debugger_request_t request;
memset(&request, 0, sizeof(request));
int status = read_request(fd, &request);
if (!status) {
XLOG("BOOM: pid=%d uid=%d gid=%d tid=%d\n",
request.pid, request.uid, request.gid, request.tid);
debugger_request_t request;
memset(&request, 0, sizeof(request));
int status = read_request(fd, &request);
if (!status) {
XLOG("BOOM: pid=%d uid=%d gid=%d tid=%d\n",
request.pid, request.uid, request.gid, request.tid);
/* At this point, the thread that made the request is blocked in
* 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.
*
* The PTRACE_ATTACH sends a SIGSTOP to the target process, but it
* won't necessarily have stopped by the time ptrace() returns. (We
* currently assume it does.) We write to the file descriptor to
* ensure that it can run as soon as we call PTRACE_CONT below.
* See details in bionic/libc/linker/debugger.c, in function
* debugger_signal_handler().
*/
if (ptrace(PTRACE_ATTACH, request.tid, 0, 0)) {
LOG("ptrace attach failed: %s\n", strerror(errno));
} else {
bool detach_failed = false;
bool attach_gdb = should_attach_gdb(&request);
if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) {
LOG("failed responding to client: %s\n", strerror(errno));
} else {
char* tombstone_path = NULL;
// At this point, the thread that made the request is blocked in
// 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.
//
// The PTRACE_ATTACH sends a SIGSTOP to the target process, but it
// won't necessarily have stopped by the time ptrace() returns. (We
// currently assume it does.) We write to the file descriptor to
// ensure that it can run as soon as we call PTRACE_CONT below.
// See details in bionic/libc/linker/debugger.c, in function
// debugger_signal_handler().
if (ptrace(PTRACE_ATTACH, request.tid, 0, 0)) {
LOG("ptrace attach failed: %s\n", strerror(errno));
} else {
bool detach_failed = false;
bool attach_gdb = should_attach_gdb(&request);
if (TEMP_FAILURE_RETRY(write(fd, "\0", 1)) != 1) {
LOG("failed responding to client: %s\n", strerror(errno));
} else {
char* tombstone_path = NULL;
if (request.action == DEBUGGER_ACTION_CRASH) {
close(fd);
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);
}
if (request.action == DEBUGGER_ACTION_CRASH) {
close(fd);
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);
}
}
if (fd >= 0) {
close(fd);
}
}
if (fd >= 0) {
close(fd);
}
}
static int do_server() {
int s;
struct sigaction act;
int logsocket = -1;
int s;
struct sigaction act;
int logsocket = -1;
/*
* debuggerd crashes can't be reported to debuggerd. Reset all of the
* crash handlers.
*/
signal(SIGILL, SIG_DFL);
signal(SIGABRT, SIG_DFL);
signal(SIGBUS, SIG_DFL);
signal(SIGFPE, SIG_DFL);
signal(SIGSEGV, SIG_DFL);
// debuggerd crashes can't be reported to debuggerd. Reset all of the
// crash handlers.
signal(SIGILL, SIG_DFL);
signal(SIGABRT, SIG_DFL);
signal(SIGBUS, SIG_DFL);
signal(SIGFPE, SIG_DFL);
signal(SIGSEGV, SIG_DFL);
#ifdef SIGSTKFLT
signal(SIGSTKFLT, SIG_DFL);
signal(SIGSTKFLT, SIG_DFL);
#endif
// Ignore failed writes to closed sockets
signal(SIGPIPE, SIG_IGN);
// Ignore failed writes to closed sockets
signal(SIGPIPE, SIG_IGN);
logsocket = socket_local_client("logd",
ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM);
if(logsocket < 0) {
logsocket = -1;
} else {
fcntl(logsocket, F_SETFD, FD_CLOEXEC);
logsocket = socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM);
if (logsocket < 0) {
logsocket = -1;
} else {
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;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask,SIGCHLD);
act.sa_flags = SA_NOCLDWAIT;
sigaction(SIGCHLD, &act, 0);
fcntl(fd, F_SETFD, FD_CLOEXEC);
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;
}
fcntl(fd, F_SETFD, FD_CLOEXEC);
handle_request(fd);
}
return 0;
handle_request(fd);
}
return 0;
}
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) {
fflush(stdout);
if (dump_backtrace_to_file(tid, fileno(stdout)) < 0) {
fputs("Error dumping backtrace.\n", stderr);
return 1;
}
} else {
char tombstone_path[PATH_MAX];
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);
if (dump_backtrace) {
fflush(stdout);
if (dump_backtrace_to_file(tid, fileno(stdout)) < 0) {
fputs("Error dumping backtrace.\n", stderr);
return 1;
}
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() {
fputs("Usage: -b [<tid>]\n"
" -b dump backtrace to console, otherwise dump full tombstone file\n"
"\n"
"If tid specified, sends a request to debuggerd to dump that task.\n"
"Otherwise, starts the debuggerd server.\n", stderr);
fputs("Usage: -b [<tid>]\n"
" -b dump backtrace to console, otherwise dump full tombstone file\n"
"\n"
"If tid specified, sends a request to debuggerd to dump that task.\n"
"Otherwise, starts the debuggerd server.\n", stderr);
}
int main(int argc, char** argv) {
if (argc == 1) {
return do_server();
}
if (argc == 1) {
return do_server();
}
bool dump_backtrace = false;
bool have_tid = false;
pid_t tid = 0;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-b")) {
dump_backtrace = true;
} else if (!have_tid) {
tid = atoi(argv[i]);
have_tid = true;
} else {
usage();
return 1;
}
bool dump_backtrace = false;
bool have_tid = false;
pid_t tid = 0;
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-b")) {
dump_backtrace = true;
} else if (!have_tid) {
tid = atoi(argv[i]);
have_tid = true;
} else {
usage();
return 1;
}
if (!have_tid) {
usage();
return 1;
}
return do_explicit_dump(tid, dump_backtrace);
}
if (!have_tid) {
usage();
return 1;
}
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 <stdlib.h>
#include <string.h>
@ -12,208 +28,195 @@
#include <errno.h>
#include <cutils/log.h>
static struct pollfd *ufds;
static char **device_names;
static struct pollfd* ufds;
static char** device_names;
static int nfds;
static int open_device(const char *device)
{
int version;
int fd;
struct pollfd *new_ufds;
char **new_device_names;
char name[80];
char location[80];
char idstr[80];
struct input_id id;
static int open_device(const char* device) {
int version;
int fd;
struct pollfd* new_ufds;
char** new_device_names;
char name[80];
char location[80];
char idstr[80];
struct input_id id;
fd = open(device, O_RDWR);
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;
}
}
fd = open(device, O_RDWR);
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) {
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 res;
char devname[PATH_MAX];
char *filename;
char event_buf[512];
int event_size;
int event_pos = 0;
struct inotify_event *event;
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;
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;
}
//printf("got %d bytes of event information\n", res);
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;
}
return -1;
}
static int scan_dir(const char *dirname)
{
char devname[PATH_MAX];
char *filename;
DIR *dir;
struct dirent *de;
dir = opendir(dirname);
if(dir == NULL)
return -1;
strcpy(devname, dirname);
filename = devname + strlen(devname);
*filename++ = '/';
while((de = readdir(dir))) {
if(de->d_name[0] == '.' &&
(de->d_name[1] == '\0' ||
(de->d_name[1] == '.' && de->d_name[2] == '\0')))
continue;
strcpy(filename, de->d_name);
static int read_notify(const char* dirname, int nfd) {
int res;
char devname[PATH_MAX];
char* filename;
char event_buf[512];
int event_size;
int event_pos = 0;
struct inotify_event *event;
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;
}
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);
} else {
close_device(devname);
}
}
closedir(dir);
return 0;
event_size = sizeof(*event) + event->len;
res -= event_size;
event_pos += event_size;
}
return 0;
}
int init_getevent()
{
int res;
const char *device_path = "/dev/input";
nfds = 1;
ufds = reinterpret_cast<pollfd*>(calloc(1, sizeof(ufds[0])));
ufds[0].fd = inotify_init();
ufds[0].events = POLLIN;
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;
static int scan_dir(const char* dirname) {
char devname[PATH_MAX];
char* filename;
DIR* dir;
struct dirent* de;
dir = opendir(dirname);
if (dir == NULL)
return -1;
strcpy(devname, dirname);
filename = devname + strlen(devname);
*filename++ = '/';
while ((de = readdir(dir))) {
if ((de->d_name[0] == '.' && de->d_name[1] == '\0') ||
(de->d_name[1] == '.' && de->d_name[2] == '\0'))
continue;
strcpy(filename, de->d_name);
open_device(devname);
}
closedir(dir);
return 0;
}
void uninit_getevent()
{
int i;
for(i = 0; i < nfds; i++) {
close(ufds[i].fd);
}
free(ufds);
ufds = 0;
nfds = 0;
int init_getevent() {
int res;
const char* device_path = "/dev/input";
nfds = 1;
ufds = reinterpret_cast<pollfd*>(calloc(1, sizeof(ufds[0])));
ufds[0].fd = inotify_init();
ufds[0].events = POLLIN;
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)
{
int res;
int i;
int pollres;
const char *device_path = "/dev/input";
while(1) {
pollres = poll(ufds, nfds, timeout);
if (pollres == 0) {
return 1;
}
if(ufds[0].revents & POLLIN) {
read_notify(device_path, ufds[0].fd);
}
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 < (int)sizeof(event)) {
fprintf(stderr, "could not get event\n");
return -1;
}
return 0;
}
}
void uninit_getevent() {
int i;
for (i = 0; i < nfds; i++) {
close(ufds[i].fd);
}
free(ufds);
ufds = 0;
nfds = 0;
}
int get_event(struct input_event* event, int timeout) {
int res;
int i;
int pollres;
const char* device_path = "/dev/input";
while (1) {
pollres = poll(ufds, nfds, timeout);
if (pollres == 0) {
return 1;
}
if (ufds[0].revents & POLLIN) {
read_notify(device_path, ufds[0].fd);
}
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
**
** 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.
*/
/*
* Copyright 2012, 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 <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
@ -31,144 +29,134 @@
#include "../utility.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 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) {
char code_buffer[64]; /* actual 8+1+((8+1)*4) + 1 == 45 */
char ascii_buffer[32]; /* actual 16 + 1 == 17 */
uintptr_t p, end;
char code_buffer[64]; // actual 8+1+((8+1)*4) + 1 == 45
char ascii_buffer[32]; // actual 16 + 1 == 17
uintptr_t p, end;
p = addr & ~3;
p -= 32;
if (p > addr) {
/* catch underflow */
p = 0;
}
end = p + 80;
/* catch overflow; 'end - p' has to be multiples of 16 */
while (end < p)
end -= 16;
p = addr & ~3;
p -= 32;
if (p > addr) {
// catch underflow
p = 0;
}
end = p + 80;
// catch overflow; 'end - p' has to be multiples of 16
while (end < p)
end -= 16;
/* Dump the code around PC as:
* addr contents ascii
* 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q
* 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p......
*/
while (p < end) {
char* asc_out = ascii_buffer;
// Dump the code around PC as:
// addr contents ascii
// 00008d34 ef000000 e8bd0090 e1b00000 512fff1e ............../Q
// 00008d44 ea00b1f9 e92d0090 e3a070fc ef000000 ......-..p......
while (p < end) {
char* asc_out = ascii_buffer;
sprintf(code_buffer, "%08x ", p);
sprintf(code_buffer, "%08x ", p);
int i;
for (i = 0; i < 4; i++) {
/*
* If we see (data == -1 && errno != 0), we know that the ptrace
* call failed, probably because we're dumping memory in an
* unmapped or inaccessible page. I don't know if there's
* value in making that explicit in the output -- it likely
* just complicates parsing and clarifies nothing for the
* enlightened reader.
*/
long data = ptrace(PTRACE_PEEKTEXT, tid, (void*)p, NULL);
sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
int i;
for (i = 0; i < 4; i++) {
// If we see (data == -1 && errno != 0), we know that the ptrace
// call failed, probably because we're dumping memory in an
// unmapped or inaccessible page. I don't know if there's
// value in making that explicit in the output -- it likely
// just complicates parsing and clarifies nothing for the
// enlightened reader.
long data = ptrace(PTRACE_PEEKTEXT, tid, (void*)p, NULL);
sprintf(code_buffer + strlen(code_buffer), "%08lx ", data);
int j;
for (j = 0; j < 4; j++) {
/*
* Our isprint() allows high-ASCII characters that display
* differently (often badly) in different viewers, so we
* just use a simpler test.
*/
char val = (data >> (j*8)) & 0xff;
if (val >= 0x20 && val < 0x7f) {
*asc_out++ = val;
} else {
*asc_out++ = '.';
}
}
p += 4;
int j;
for (j = 0; j < 4; j++) {
// Our isprint() allows high-ASCII characters that display
// differently (often badly) in different viewers, so we
// just use a simpler test.
char val = (data >> (j*8)) & 0xff;
if (val >= 0x20 && val < 0x7f) {
*asc_out++ = val;
} else {
*asc_out++ = '.';
}
*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
* for the crashing thread.
*/
// If configured to do so, dump memory around *all* registers
// for the crashing thread.
void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
pt_regs_mips_t r;
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) {
return;
pt_regs_mips_t r;
if (ptrace(PTRACE_GETREGS, tid, 0, &r)) {
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) {
static const char REG_NAMES[] = "$0atv0v1a0a1a2a3t0t1t2t3t4t5t6t7s0s1s2s3s4s5s6s7t8t9k0k1gpsps8ra";
unsigned int pc = R(r.cp0_epc);
unsigned int ra = R(r.regs[31]);
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;
_LOG(log, scope_flags, "\ncode around pc:\n");
dump_memory(log, tid, (uintptr_t)pc, scope_flags);
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);
}
}
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);
}
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)
{
pt_regs_mips_t r;
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
void dump_registers(log_t* log, pid_t tid, int scope_flags) {
pt_regs_mips_t r;
if(ptrace(PTRACE_GETREGS, tid, 0, &r)) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
_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]));
_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]));
_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]));
_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]));
_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]));
_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]));
_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]));
_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]));
_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));
_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]));
_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]));
_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]));
_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]));
_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]));
_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]));
_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]));
_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]));
_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));
}

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 <sys/types.h>
#include <corkscrew/ptrace.h>
/* Creates a tombstone file and writes the crash dump to it.
* 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,

193
debuggerd/utility.cpp
View file

@ -1,22 +1,20 @@
/* system/debuggerd/utility.c
**
** Copyright 2008, 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.
*/
/*
* Copyright 2008, 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 <stddef.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
@ -30,101 +28,102 @@
#include "utility.h"
const int sleep_time_usec = 50000; /* 0.05 seconds */
const int max_total_sleep_usec = 10000000; /* 10 seconds */
const int sleep_time_usec = 50000; // 0.05 seconds
const int max_total_sleep_usec = 10000000; // 10 seconds
static int write_to_am(int fd, const char* buf, int len) {
int to_write = len;
while (to_write > 0) {
int written = TEMP_FAILURE_RETRY( write(fd, buf + len - to_write, to_write) );
if (written < 0) {
/* hard failure */
LOG("AM write failure (%d / %s)\n", errno, strerror(errno));
return -1;
}
to_write -= written;
int to_write = len;
while (to_write > 0) {
int written = TEMP_FAILURE_RETRY( write(fd, buf + len - to_write, to_write) );
if (written < 0) {
// hard failure
LOG("AM write failure (%d / %s)\n", errno, strerror(errno));
return -1;
}
return len;
to_write -= written;
}
return len;
}
void _LOG(log_t* log, int scopeFlags, const char *fmt, ...) {
char buf[512];
bool want_tfd_write;
bool want_log_write;
bool want_amfd_write;
int len = 0;
void _LOG(log_t* log, int scopeFlags, const char* fmt, ...) {
char buf[512];
bool want_tfd_write;
bool want_log_write;
bool want_amfd_write;
int len = 0;
va_list ap;
va_start(ap, fmt);
va_list ap;
va_start(ap, fmt);
// where is the information going to go?
want_tfd_write = log && log->tfd >= 0;
want_log_write = IS_AT_FAULT(scopeFlags) && (!log || !log->quiet);
want_amfd_write = IS_AT_FAULT(scopeFlags) && !IS_SENSITIVE(scopeFlags) && log && log->amfd >= 0;
// where is the information going to go?
want_tfd_write = log && log->tfd >= 0;
want_log_write = IS_AT_FAULT(scopeFlags) && (!log || !log->quiet);
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 (want_tfd_write || want_amfd_write) {
vsnprintf(buf, sizeof(buf), fmt, ap);
len = strlen(buf);
// if we're going to need the literal string, generate it once here
if (want_tfd_write || want_amfd_write) {
vsnprintf(buf, sizeof(buf), fmt, ap);
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) {
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);
}
va_end(ap);
}
int wait_for_signal(pid_t tid, int* total_sleep_time_usec) {
for (;;) {
int status;
pid_t n = waitpid(tid, &status, __WALL | WNOHANG);
if (n < 0) {
if(errno == EAGAIN) continue;
LOG("waitpid failed: %s\n", strerror(errno));
return -1;
} else if (n > 0) {
XLOG("waitpid: n=%d status=%08x\n", n, status);
if (WIFSTOPPED(status)) {
return WSTOPSIG(status);
} else {
LOG("unexpected waitpid response: n=%d, status=%08x\n", n, status);
return -1;
}
}
if (*total_sleep_time_usec > max_total_sleep_usec) {
LOG("timed out waiting for tid=%d to die\n", tid);
return -1;
}
/* not ready yet */
XLOG("not ready yet\n");
usleep(sleep_time_usec);
*total_sleep_time_usec += sleep_time_usec;
for (;;) {
int status;
pid_t n = waitpid(tid, &status, __WALL | WNOHANG);
if (n < 0) {
if (errno == EAGAIN)
continue;
LOG("waitpid failed: %s\n", strerror(errno));
return -1;
} else if (n > 0) {
XLOG("waitpid: n=%d status=%08x\n", n, status);
if (WIFSTOPPED(status)) {
return WSTOPSIG(status);
} else {
LOG("unexpected waitpid response: n=%d, status=%08x\n", n, status);
return -1;
}
}
if (*total_sleep_time_usec > max_total_sleep_usec) {
LOG("timed out waiting for tid=%d to die\n", tid);
return -1;
}
// not ready yet
XLOG("not ready yet\n");
usleep(sleep_time_usec);
*total_sleep_time_usec += sleep_time_usec;
}
}
void wait_for_stop(pid_t tid, int* total_sleep_time_usec) {
siginfo_t si;
while (TEMP_FAILURE_RETRY(ptrace(PTRACE_GETSIGINFO, tid, 0, &si)) < 0 && errno == ESRCH) {
if (*total_sleep_time_usec > max_total_sleep_usec) {
LOG("timed out waiting for tid=%d to stop\n", tid);
break;
}
usleep(sleep_time_usec);
*total_sleep_time_usec += sleep_time_usec;
siginfo_t si;
while (TEMP_FAILURE_RETRY(ptrace(PTRACE_GETSIGINFO, tid, 0, &si)) < 0 && errno == ESRCH) {
if (*total_sleep_time_usec > max_total_sleep_usec) {
LOG("timed out waiting for tid=%d to stop\n", tid);
break;
}
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
**
** 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.
*/
* Copyright 2006, 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 <stddef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.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) {
struct pt_regs r;
if (ptrace(PTRACE_GETREGS, tid, 0, &r) == -1) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
_LOG(log, scope_flags, " eax %08lx ebx %08lx ecx %08lx edx %08lx\n",
r.eax, r.ebx, r.ecx, r.edx);
_LOG(log, scope_flags, " esi %08lx edi %08lx\n",
r.esi, r.edi);
_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);
_LOG(log, scope_flags, " eip %08lx ebp %08lx esp %08lx flags %08lx\n",
r.eip, r.ebp, r.esp, r.eflags);
struct pt_regs r;
if (ptrace(PTRACE_GETREGS, tid, 0, &r) == -1) {
_LOG(log, scope_flags, "cannot get registers: %s\n", strerror(errno));
return;
}
_LOG(log, scope_flags, " eax %08lx ebx %08lx ecx %08lx edx %08lx\n",
r.eax, r.ebx, r.ecx, r.edx);
_LOG(log, scope_flags, " esi %08lx edi %08lx\n",
r.esi, r.edi);
_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);
_LOG(log, scope_flags, " eip %08lx ebp %08lx esp %08lx flags %08lx\n",
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
// for a single frame.
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 Tid() { return backtrace_.tid; }
@ -68,9 +69,16 @@ public:
const backtrace_t* GetBacktrace() { return &backtrace_; }
const backtrace_frame_data_t* GetFrame(size_t frame_num) {
if (frame_num > NumFrames()) {
return NULL;
}
return &backtrace_.frames[frame_num];
}
const backtrace_map_info_t* GetMapList() {
return map_info_;
}
protected:
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;
typedef struct {
size_t num; /* The current fame number. */
uintptr_t pc; /* The absolute pc. */
uintptr_t sp; /* The top of the stack. */
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) {
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;
if (frame->map_name) {
map_name = frame->map_name;
@ -142,13 +145,13 @@ std::string Backtrace::FormatFrameData(size_t frame_num) {
char buf[512];
if (frame->func_name && frame->func_offset) {
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);
} 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);
} 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);
}

2
libbacktrace/Corkscrew.cpp
View file

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

326
libbacktrace/backtrace_test.cpp
View file

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