am 536b81af: resolved conflicts for merge of 053b8654 to jb-dev-plus-aosp (aff44661) · Commits · e / os / android_system_core

debuggerd/Android.mk

+9 −3

Original line number	Diff line number	Diff line
		@@ -5,9 +5,15 @@ ifneq ($(filter arm x86,$(TARGET_ARCH)),)
		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= debuggerd.c utility.c getevent.c $(TARGET_ARCH)/machine.c

		LOCAL_CFLAGS := -Wall -Werror -std=gnu99
		LOCAL_SRC_FILES:= \
		backtrace.c \
		debuggerd.c \
		getevent.c \
		tombstone.c \
		utility.c \
		$(TARGET_ARCH)/machine.c

		LOCAL_CFLAGS := -Wall -Wno-unused-parameter -std=gnu99
		LOCAL_MODULE := debuggerd

		ifeq ($(ARCH_ARM_HAVE_VFP),true)

debuggerd/arm/machine.c

+82 −38

Original line number	Diff line number	Diff line
		@@ -15,23 +15,17 @@
		** limitations under the License.
		*/

		#include <stddef.h>
		#include <stdbool.h>
		#include <stdlib.h>
		#include <string.h>
		#include <stdio.h>
		#include <errno.h>
		#include <signal.h>
		#include <pthread.h>
		#include <fcntl.h>
		#include <sys/types.h>
		#include <dirent.h>

		#include <sys/ptrace.h>
		#include <sys/wait.h>
		#include <sys/exec_elf.h>
		#include <sys/stat.h>

		#include <cutils/sockets.h>
		#include <cutils/properties.h>
		#include <corkscrew/ptrace.h>

		#include <linux/input.h>
		#include <linux/user.h>

		#include "../utility.h"
		@@ -48,11 +42,72 @@
		#endif
		#endif

		static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, bool at_fault) {
		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;

		/* 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);

		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;
		}
		*asc_out = '\0';
		_LOG(log, !at_fault, " %s %s\n", code_buffer, ascii_buffer);
		}
		}

		/*
		* If configured to do so, dump memory around all registers
		* for the crashing thread.
		*/
		static void dump_memory_and_code(int tfd, pid_t tid, bool at_fault) {
		void dump_memory_and_code(const ptrace_context_t* context __attribute((unused)),
		log_t* log, pid_t tid, bool at_fault) {
		struct pt_regs regs;
		if(ptrace(PTRACE_GETREGS, tid, 0, &regs)) {
		return;
		@@ -73,38 +128,38 @@ static void dump_memory_and_code(int tfd, pid_t tid, bool at_fault) {
		continue;
		}

		_LOG(tfd, false, "\nmemory near %.2s:\n", &REG_NAMES[reg * 2]);
		dump_memory(tfd, tid, addr, at_fault);
		_LOG(log, false, "\nmemory near %.2s:\n", &REG_NAMES[reg * 2]);
		dump_memory(log, tid, addr, at_fault);
		}
		}

		_LOG(tfd, !at_fault, "\ncode around pc:\n");
		dump_memory(tfd, tid, (uintptr_t)regs.ARM_pc, at_fault);
		_LOG(log, !at_fault, "\ncode around pc:\n");
		dump_memory(log, tid, (uintptr_t)regs.ARM_pc, at_fault);

		if (regs.ARM_pc != regs.ARM_lr) {
		_LOG(tfd, !at_fault, "\ncode around lr:\n");
		dump_memory(tfd, tid, (uintptr_t)regs.ARM_lr, at_fault);
		_LOG(log, !at_fault, "\ncode around lr:\n");
		dump_memory(log, tid, (uintptr_t)regs.ARM_lr, at_fault);
		}
		}

		void dump_registers(const ptrace_context_t* context __attribute((unused)),
		int tfd, pid_t tid, bool at_fault)
		log_t* log, pid_t tid, bool at_fault)
		{
		struct pt_regs r;
		bool only_in_tombstone = !at_fault;

		if(ptrace(PTRACE_GETREGS, tid, 0, &r)) {
		_LOG(tfd, only_in_tombstone, "cannot get registers: %s\n", strerror(errno));
		_LOG(log, only_in_tombstone, "cannot get registers: %s\n", strerror(errno));
		return;
		}

		_LOG(tfd, only_in_tombstone, " r0 %08x r1 %08x r2 %08x r3 %08x\n",
		_LOG(log, only_in_tombstone, " 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(tfd, only_in_tombstone, " r4 %08x r5 %08x r6 %08x r7 %08x\n",
		_LOG(log, only_in_tombstone, " 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(tfd, only_in_tombstone, " r8 %08x r9 %08x sl %08x fp %08x\n",
		_LOG(log, only_in_tombstone, " 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(tfd, only_in_tombstone, " ip %08x sp %08x lr %08x pc %08x cpsr %08x\n",
		_LOG(log, only_in_tombstone, " 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);

		@@ -113,25 +168,14 @@ void dump_registers(const ptrace_context_t* context __attribute((unused)),
		int i;

		if(ptrace(PTRACE_GETVFPREGS, tid, 0, &vfp_regs)) {
		_LOG(tfd, only_in_tombstone, "cannot get registers: %s\n", strerror(errno));
		_LOG(log, only_in_tombstone, "cannot get registers: %s\n", strerror(errno));
		return;
		}

		for (i = 0; i < NUM_VFP_REGS; i += 2) {
		_LOG(tfd, only_in_tombstone, " d%-2d %016llx d%-2d %016llx\n",
		_LOG(log, only_in_tombstone, " d%-2d %016llx d%-2d %016llx\n",
		i, vfp_regs.fpregs[i], i+1, vfp_regs.fpregs[i+1]);
		}
		_LOG(tfd, only_in_tombstone, " scr %08lx\n", vfp_regs.fpscr);
		_LOG(log, only_in_tombstone, " scr %08lx\n", vfp_regs.fpscr);
		#endif
		}

		void dump_thread(const ptrace_context_t* context, int tfd, pid_t tid, bool at_fault) {
		dump_registers(context, tfd, tid, at_fault);

		dump_backtrace_and_stack(context, tfd, tid, at_fault);

		if (at_fault) {
		dump_memory_and_code(tfd, tid, at_fault);
		dump_nearby_maps(context, tfd, tid);
		}
		}

debuggerd/backtrace.c

0 → 100644

+149 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 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>
		#include <time.h>
		#include <errno.h>
		#include <limits.h>
		#include <dirent.h>
		#include <unistd.h>
		#include <sys/types.h>
		#include <sys/ptrace.h>

		#include <corkscrew/backtrace.h>

		#include "tombstone.h"
		#include "utility.h"

		#define STACK_DEPTH 32

		static void dump_process_header(log_t* log, pid_t pid) {
		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);
		}

		time_t t = time(NULL);
		struct tm tm;
		localtime_r(&t, &tm);
		char timestr[64];
		strftime(timestr, sizeof(timestr), "%F %T", &tm);
		_LOG(log, false, "\n\n----- pid %d at %s -----\n", pid, timestr);

		if (procname) {
		_LOG(log, false, "\nCmd line: %s\n", procname);
		}
		}

		static void dump_process_footer(log_t* log, pid_t pid) {
		_LOG(log, false, "\n----- end %d -----\n", pid);
		}

		static void dump_thread(log_t* log, pid_t tid, ptrace_context_t* context, 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';
		}
		}
		}

		_LOG(log, false, "\n\"%s\" sysTid=%d\n", threadname ? threadname : "<unknown>", tid);

		if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) {
		_LOG(log, false, "Could not attach to thread: %s\n", strerror(errno));
		return;
		}

		wait_for_stop(tid, total_sleep_time_usec);

		backtrace_frame_t backtrace[STACK_DEPTH];
		ssize_t frames = unwind_backtrace_ptrace(tid, context, backtrace, 0, STACK_DEPTH);
		if (frames <= 0) {
		_LOG(log, false, "Could not obtain stack trace for thread.\n");
		} else {
		backtrace_symbol_t backtrace_symbols[STACK_DEPTH];
		get_backtrace_symbols_ptrace(context, backtrace, frames, backtrace_symbols);
		for (size_t i = 0; i < (size_t)frames; i++) {
		char line[MAX_BACKTRACE_LINE_LENGTH];
		format_backtrace_line(i, &backtrace[i], &backtrace_symbols[i],
		line, MAX_BACKTRACE_LINE_LENGTH);
		_LOG(log, false, " %s\n", line);
		}
		free_backtrace_symbols(backtrace_symbols, frames);
		}

		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, pid_t pid, pid_t tid, bool* detach_failed,
		int* total_sleep_time_usec) {
		log_t log;
		log.tfd = fd;
		log.quiet = true;

		ptrace_context_t* context = load_ptrace_context(tid);
		dump_process_header(&log, pid);
		dump_thread(&log, tid, context, 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) {
		struct dirent debuf;
		struct dirent *de;
		while (!readdir_r(d, &debuf, &de) && de) {
		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;
		}

		dump_thread(&log, new_tid, context, false, detach_failed, total_sleep_time_usec);
		}
		closedir(d);
		}

		dump_process_footer(&log, pid);
		free_ptrace_context(context);
		}

debuggerd/backtrace.h

0 → 100644

+31 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 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.
		*/

		#ifndef _DEBUGGERD_BACKTRACE_H
		#define _DEBUGGERD_BACKTRACE_H

		#include <stddef.h>
		#include <stdbool.h>
		#include <sys/types.h>

		#include <corkscrew/ptrace.h>

		/* 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, pid_t pid, pid_t tid, bool* detach_failed,
		int* total_sleep_time_usec);

		#endif // _DEBUGGERD_BACKTRACE_H

debuggerd/debuggerd.c

+91 −530

File changed.

Preview size limit exceeded, changes collapsed.