am 7716aef1: Uploaded native crash dumps do not include memory contents (2c170667) · Commits · e / os / android_system_core

debuggerd/arm/machine.c

+20 −17

Original line number	Diff line number	Diff line
		@@ -42,7 +42,7 @@
		#endif
		#endif

		static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, bool at_fault) {
		static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, int scopeFlags) {
		char code_buffer[64]; /* actual 8+1+((8+1)4) + 1 == 45 /
		char ascii_buffer[32]; /* actual 16 + 1 == 17 */
		uintptr_t p, end;
		@@ -102,7 +102,7 @@ static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, bool at_fault) {
		p += 4;
		}
		*asc_out = '\0';
		_LOG(log, !at_fault, " %s %s\n", code_buffer, ascii_buffer);
		_LOG(log, scopeFlags, " %s %s\n", code_buffer, ascii_buffer);
		}
		}

		@@ -117,6 +117,8 @@ void dump_memory_and_code(const ptrace_context_t* context __attribute((unused)),
		return;
		}

		int scopeFlags = at_fault ? SCOPE_AT_FAULT : 0;

		if (at_fault && DUMP_MEMORY_FOR_ALL_REGISTERS) {
		static const char REG_NAMES[] = "r0r1r2r3r4r5r6r7r8r9slfpipsp";

		@@ -132,17 +134,18 @@ void dump_memory_and_code(const ptrace_context_t* context __attribute((unused)),
		continue;
		}

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

		_LOG(log, !at_fault, "\ncode around pc:\n");
		dump_memory(log, tid, (uintptr_t)regs.ARM_pc, at_fault);
		/* explicitly allow upload of code dump logging */
		_LOG(log, scopeFlags, "\ncode around pc:\n");
		dump_memory(log, tid, (uintptr_t)regs.ARM_pc, scopeFlags);

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

		@@ -150,20 +153,20 @@ void dump_registers(const ptrace_context_t* context __attribute((unused)),
		log_t* log, pid_t tid, bool at_fault)
		{
		struct pt_regs r;
		bool only_in_tombstone = !at_fault;
		int scopeFlags = at_fault ? SCOPE_AT_FAULT : 0;

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

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

		@@ -172,14 +175,14 @@ void dump_registers(const ptrace_context_t* context __attribute((unused)),
		int i;

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

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

debuggerd/backtrace.c

+8 −7

Original line number	Diff line number	Diff line
		@@ -51,15 +51,15 @@ static void dump_process_header(log_t* log, pid_t pid) {
		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);
		_LOG(log, SCOPE_AT_FAULT, "\n\n----- pid %d at %s -----\n", pid, timestr);

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

		static void dump_process_footer(log_t* log, pid_t pid) {
		_LOG(log, false, "\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, ptrace_context_t* context, bool attached,
		@@ -81,10 +81,11 @@ static void dump_thread(log_t* log, pid_t tid, ptrace_context_t* context, bool a
		}
		}

		_LOG(log, false, "\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, false, "Could not attach to thread: %s\n", strerror(errno));
		_LOG(log, SCOPE_AT_FAULT, "Could not attach to thread: %s\n", strerror(errno));
		return;
		}

		@@ -93,7 +94,7 @@ static void dump_thread(log_t* log, pid_t tid, ptrace_context_t* context, bool a
		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");
		_LOG(log, SCOPE_AT_FAULT, "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);
		@@ -101,7 +102,7 @@ static void dump_thread(log_t* log, pid_t tid, ptrace_context_t* context, bool a
		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);
		_LOG(log, SCOPE_AT_FAULT, " %s\n", line);
		}
		free_backtrace_symbols(backtrace_symbols, frames);
		}

debuggerd/mips/machine.c

+20 −19

Original line number	Diff line number	Diff line
		@@ -36,7 +36,7 @@

		#define R(x) ((unsigned int)(x))

		static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, bool at_fault) {
		static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, int scopeFlags) {
		char code_buffer[64]; /* actual 8+1+((8+1)4) + 1 == 45 /
		char ascii_buffer[32]; /* actual 16 + 1 == 17 */
		uintptr_t p, end;
		@@ -92,7 +92,7 @@ static void dump_memory(log_t* log, pid_t tid, uintptr_t addr, bool at_fault) {
		p += 4;
		}
		*asc_out = '\0';
		_LOG(log, !at_fault, " %s %s\n", code_buffer, ascii_buffer);
		_LOG(log, scopeFlags, " %s %s\n", code_buffer, ascii_buffer);
		}
		}

		@@ -107,6 +107,7 @@ void dump_memory_and_code(const ptrace_context_t* context __attribute((unused)),
		return;
		}

		int scopeFlags = at_fault ? SCOPE_AT_FAULT : 0;
		if (at_fault && DUMP_MEMORY_FOR_ALL_REGISTERS) {
		static const char REG_NAMES[] = "$0atv0v1a0a1a2a3t0t1t2t3t4t5t6t7s0s1s2s3s4s5s6s7t8t9k0k1gpsps8ra";

		@@ -129,20 +130,20 @@ void dump_memory_and_code(const ptrace_context_t* context __attribute((unused)),
		continue;
		}

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

		unsigned int pc = R(r.cp0_epc);
		unsigned int ra = R(r.regs[31]);

		_LOG(log, !at_fault, "\ncode around pc:\n");
		dump_memory(log, tid, (uintptr_t)pc, at_fault);
		_LOG(log, scopeFlags, "\ncode around pc:\n");
		dump_memory(log, tid, (uintptr_t)pc, scopeFlags);

		if (pc != ra) {
		_LOG(log, !at_fault, "\ncode around ra:\n");
		dump_memory(log, tid, (uintptr_t)ra, at_fault);
		_LOG(log, scopeFlags, "\ncode around ra:\n");
		dump_memory(log, tid, (uintptr_t)ra, scopeFlags);
		}
		}

		@@ -150,29 +151,29 @@ void dump_registers(const ptrace_context_t* context __attribute((unused)),
		log_t* log, pid_t tid, bool at_fault)
		{
		pt_regs_mips_t r;
		bool only_in_tombstone = !at_fault;
		int scopeFlags = at_fault ? SCOPE_AT_FAULT : 0;

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

		_LOG(log, only_in_tombstone, " zr %08x at %08x v0 %08x v1 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " a0 %08x a1 %08x a2 %08x a3 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " t0 %08x t1 %08x t2 %08x t3 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " t4 %08x t5 %08x t6 %08x t7 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " s0 %08x s1 %08x s2 %08x s3 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " s4 %08x s5 %08x s6 %08x s7 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " t8 %08x t9 %08x k0 %08x k1 %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " gp %08x sp %08x s8 %08x ra %08x\n",
		_LOG(log, scopeFlags, " 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, only_in_tombstone, " hi %08x lo %08x bva %08x epc %08x\n",
		_LOG(log, scopeFlags, " hi %08x lo %08x bva %08x epc %08x\n",
		R(r.hi), R(r.lo), R(r.cp0_badvaddr), R(r.cp0_epc));
		}

debuggerd/tombstone.c

+39 −38

Original line number	Diff line number	Diff line
		@@ -163,7 +163,7 @@ static void dump_revision_info(log_t* log)

		property_get("ro.revision", revision, "unknown");

		_LOG(log, false, "Revision: '%s'\n", revision);
		_LOG(log, SCOPE_AT_FAULT, "Revision: '%s'\n", revision);
		}

		static void dump_build_info(log_t* log)
		@@ -172,7 +172,7 @@ static void dump_build_info(log_t* log)

		property_get("ro.build.fingerprint", fingerprint, "unknown");

		_LOG(log, false, "Build fingerprint: '%s'\n", fingerprint);
		_LOG(log, SCOPE_AT_FAULT, "Build fingerprint: '%s'\n", fingerprint);
		}

		static void dump_fault_addr(log_t* log, pid_t tid, int sig)
		@@ -181,14 +181,14 @@ static void dump_fault_addr(log_t* log, pid_t tid, int sig)

		memset(&si, 0, sizeof(si));
		if(ptrace(PTRACE_GETSIGINFO, tid, 0, &si)){
		_LOG(log, false, "cannot get siginfo: %s\n", strerror(errno));
		_LOG(log, SCOPE_AT_FAULT, "cannot get siginfo: %s\n", strerror(errno));
		} else if (signal_has_address(sig)) {
		_LOG(log, false, "signal %d (%s), code %d (%s), fault addr %08x\n",
		_LOG(log, SCOPE_AT_FAULT, "signal %d (%s), code %d (%s), fault addr %08x\n",
		sig, get_signame(sig),
		si.si_code, get_sigcode(sig, si.si_code),
		(uintptr_t) si.si_addr);
		} else {
		_LOG(log, false, "signal %d (%s), code %d (%s), fault addr --------\n",
		_LOG(log, SCOPE_AT_FAULT, "signal %d (%s), code %d (%s), fault addr --------\n",
		sig, get_signame(sig), si.si_code, get_sigcode(sig, si.si_code));
		}
		}
		@@ -221,19 +221,20 @@ static void dump_thread_info(log_t* log, pid_t pid, pid_t tid, bool at_fault) {
		fclose(fp);
		}

		_LOG(log, false, "pid: %d, tid: %d, name: %s >>> %s <<<\n", pid, tid,
		_LOG(log, SCOPE_AT_FAULT, "pid: %d, tid: %d, name: %s >>> %s <<<\n", pid, tid,
		threadname ? threadname : "UNKNOWN",
		procname ? procname : "UNKNOWN");
		} else {
		_LOG(log, true, "pid: %d, tid: %d, name: %s\n", pid, tid,
		threadname ? threadname : "UNKNOWN");
		_LOG(log, 0, "pid: %d, tid: %d, name: %s\n",
		pid, tid, threadname ? threadname : "UNKNOWN");
		}
		}

		static void dump_backtrace(const ptrace_context_t* context __attribute((unused)),
		log_t* log, pid_t tid __attribute((unused)), bool at_fault,
		const backtrace_frame_t* backtrace, size_t frames) {
		_LOG(log, !at_fault, "\nbacktrace:\n");
		int scopeFlags = at_fault ? SCOPE_AT_FAULT : 0;
		_LOG(log, scopeFlags, "\nbacktrace:\n");

		backtrace_symbol_t backtrace_symbols[STACK_DEPTH];
		get_backtrace_symbols_ptrace(context, backtrace, frames, backtrace_symbols);
		@@ -241,13 +242,13 @@ static void dump_backtrace(const ptrace_context_t* context __attribute((unused))
		char line[MAX_BACKTRACE_LINE_LENGTH];
		format_backtrace_line(i, &backtrace[i], &backtrace_symbols[i],
		line, MAX_BACKTRACE_LINE_LENGTH);
		_LOG(log, !at_fault, " %s\n", line);
		_LOG(log, scopeFlags, " %s\n", line);
		}
		free_backtrace_symbols(backtrace_symbols, frames);
		}

		static void dump_stack_segment(const ptrace_context_t* context, log_t* log, pid_t tid,
		bool only_in_tombstone, uintptr_t* sp, size_t words, int label) {
		int scopeFlags, uintptr_t* sp, size_t words, int label) {
		for (size_t i = 0; i < words; i++) {
		uint32_t stack_content;
		if (!try_get_word_ptrace(tid, *sp, &stack_content)) {
		@@ -264,28 +265,28 @@ static void dump_stack_segment(const ptrace_context_t* context, log_t* log, pid_
		uint32_t offset = stack_content - (mi->start + symbol->start);
		if (!i && label >= 0) {
		if (offset) {
		_LOG(log, only_in_tombstone, " #%02d %08x %08x %s (%s+%u)\n",
		_LOG(log, scopeFlags, " #%02d %08x %08x %s (%s+%u)\n",
		label, *sp, stack_content, mi ? mi->name : "", symbol_name, offset);
		} else {
		_LOG(log, only_in_tombstone, " #%02d %08x %08x %s (%s)\n",
		_LOG(log, scopeFlags, " #%02d %08x %08x %s (%s)\n",
		label, *sp, stack_content, mi ? mi->name : "", symbol_name);
		}
		} else {
		if (offset) {
		_LOG(log, only_in_tombstone, " %08x %08x %s (%s+%u)\n",
		_LOG(log, scopeFlags, " %08x %08x %s (%s+%u)\n",
		*sp, stack_content, mi ? mi->name : "", symbol_name, offset);
		} else {
		_LOG(log, only_in_tombstone, " %08x %08x %s (%s)\n",
		_LOG(log, scopeFlags, " %08x %08x %s (%s)\n",
		*sp, stack_content, mi ? mi->name : "", symbol_name);
		}
		}
		free(demangled_name);
		} else {
		if (!i && label >= 0) {
		_LOG(log, only_in_tombstone, " #%02d %08x %08x %s\n",
		_LOG(log, scopeFlags, " #%02d %08x %08x %s\n",
		label, *sp, stack_content, mi ? mi->name : "");
		} else {
		_LOG(log, only_in_tombstone, " %08x %08x %s\n",
		_LOG(log, scopeFlags, " %08x %08x %s\n",
		*sp, stack_content, mi ? mi->name : "");
		}
		}
		@@ -311,28 +312,28 @@ static void dump_stack(const ptrace_context_t* context, log_t* log, pid_t tid, b
		return;
		}

		_LOG(log, !at_fault, "\nstack:\n");
		int scopeFlags = SCOPE_SENSITIVE \| (at_fault ? SCOPE_AT_FAULT : 0);
		_LOG(log, scopeFlags, "\nstack:\n");

		// Dump a few words before the first frame.
		bool only_in_tombstone = !at_fault;
		uintptr_t sp = backtrace[first].stack_top - STACK_WORDS * sizeof(uint32_t);
		dump_stack_segment(context, log, tid, only_in_tombstone, &sp, STACK_WORDS, -1);
		dump_stack_segment(context, log, tid, scopeFlags, &sp, STACK_WORDS, -1);

		// Dump a few words from all successive frames.
		// Only log the first 3 frames, put the rest in the tombstone.
		for (size_t i = first; i <= last; i++) {
		const backtrace_frame_t* frame = &backtrace[i];
		if (sp != frame->stack_top) {
		_LOG(log, only_in_tombstone, " ........ ........\n");
		_LOG(log, scopeFlags, " ........ ........\n");
		sp = frame->stack_top;
		}
		if (i - first == 3) {
		only_in_tombstone = true;
		scopeFlags &= (~SCOPE_AT_FAULT);
		}
		if (i == last) {
		dump_stack_segment(context, log, tid, only_in_tombstone, &sp, STACK_WORDS, i);
		dump_stack_segment(context, log, tid, scopeFlags, &sp, STACK_WORDS, i);
		if (sp < frame->stack_top + frame->stack_size) {
		_LOG(log, only_in_tombstone, " ........ ........\n");
		_LOG(log, scopeFlags, " ........ ........\n");
		}
		} else {
		size_t words = frame->stack_size / sizeof(uint32_t);
		@@ -341,7 +342,7 @@ static void dump_stack(const ptrace_context_t* context, log_t* log, pid_t tid, b
		} else if (words > STACK_WORDS) {
		words = STACK_WORDS;
		}
		dump_stack_segment(context, log, tid, only_in_tombstone, &sp, words, i);
		dump_stack_segment(context, log, tid, scopeFlags, &sp, words, i);
		}
		}
		}
		@@ -358,13 +359,13 @@ static void dump_backtrace_and_stack(const ptrace_context_t* context, log_t* log

		static void dump_map(log_t* log, map_info_t* m, const char* what) {
		if (m != NULL) {
		_LOG(log, false, " %08x-%08x %c%c%c %s\n", m->start, m->end,
		_LOG(log, SCOPE_SENSITIVE, " %08x-%08x %c%c%c %s\n", m->start, m->end,
		m->is_readable ? 'r' : '-',
		m->is_writable ? 'w' : '-',
		m->is_executable ? 'x' : '-',
		m->name);
		} else {
		_LOG(log, false, " (no %s)\n", what);
		_LOG(log, SCOPE_SENSITIVE, " (no %s)\n", what);
		}
		}

		@@ -372,7 +373,7 @@ static void dump_nearby_maps(const ptrace_context_t* context, log_t* log, pid_t
		siginfo_t si;
		memset(&si, 0, sizeof(si));
		if (ptrace(PTRACE_GETSIGINFO, tid, 0, &si)) {
		_LOG(log, false, "cannot get siginfo for %d: %s\n",
		_LOG(log, SCOPE_SENSITIVE, "cannot get siginfo for %d: %s\n",
		tid, strerror(errno));
		return;
		}
		@@ -386,7 +387,7 @@ static void dump_nearby_maps(const ptrace_context_t* context, log_t* log, pid_t
		return;
		}

		_LOG(log, false, "\nmemory map around fault addr %08x:\n", (int)si.si_addr);
		_LOG(log, SCOPE_SENSITIVE, "\nmemory map around fault addr %08x:\n", (int)si.si_addr);

		/*
		* Search for a match, or for a hole where the match would be. The list
		@@ -464,7 +465,7 @@ static bool dump_sibling_thread_report(const ptrace_context_t* context,
		continue;
		}

		_LOG(log, true, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
		_LOG(log, 0, "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
		dump_thread_info(log, pid, new_tid, false);
		dump_thread(context, log, new_tid, false, total_sleep_time_usec);

		@@ -517,12 +518,12 @@ static void dump_log_file(log_t* log, pid_t pid, const char* filename,
		/* non-blocking EOF; we're done */
		break;
		} else {
		_LOG(log, true, "Error while reading log: %s\n",
		_LOG(log, 0, "Error while reading log: %s\n",
		strerror(errno));
		break;
		}
		} else if (actual == 0) {
		_LOG(log, true, "Got zero bytes while reading log: %s\n",
		_LOG(log, 0, "Got zero bytes while reading log: %s\n",
		strerror(errno));
		break;
		}
		@@ -542,7 +543,7 @@ static void dump_log_file(log_t* log, pid_t pid, const char* filename,
		}

		if (first) {
		_LOG(log, true, "--------- %slog %s\n",
		_LOG(log, 0, "--------- %slog %s\n",
		tailOnly ? "tail end of " : "", filename);
		first = false;
		}
		@@ -584,7 +585,7 @@ static void dump_log_file(log_t* log, pid_t pid, const char* filename,
		shortLogNext = (shortLogNext + 1) % kShortLogMaxLines;
		shortLogCount++;
		} else {
		_LOG(log, true, "%s.%03d %5d %5d %c %-8s: %s\n",
		_LOG(log, 0, "%s.%03d %5d %5d %c %-8s: %s\n",
		timeBuf, entry->nsec / 1000000, entry->pid, entry->tid,
		prioChar, tag, msg);
		}
		@@ -604,7 +605,7 @@ static void dump_log_file(log_t* log, pid_t pid, const char* filename,
		}

		for (i = 0; i < shortLogCount; i++) {
		_LOG(log, true, "%s\n", shortLog[shortLogNext]);
		_LOG(log, 0, "%s\n", shortLog[shortLogNext]);
		shortLogNext = (shortLogNext + 1) % kShortLogMaxLines;
		}
		}
		@@ -654,7 +655,7 @@ static void dump_abort_message(log_t* log, pid_t tid, uintptr_t address) {
		}
		msg[sizeof(msg) - 1] = '\0';

		_LOG(log, false, "Abort message: '%s'\n", msg);
		_LOG(log, SCOPE_AT_FAULT, "Abort message: '%s'\n", msg);
		}

		/*
		@@ -680,7 +681,7 @@ static bool dump_crash(log_t* log, pid_t pid, pid_t tid, int signal, uintptr_t a
		TEMP_FAILURE_RETRY( write(log->amfd, &datum, 4) );
		}

		_LOG(log, false,
		_LOG(log, SCOPE_AT_FAULT,
		"* * * * * * * * * * * * * * * *\n");
		dump_build_info(log);
		dump_revision_info(log);

debuggerd/utility.c

+6 −6

Original line number	Diff line number	Diff line
		@@ -39,6 +39,7 @@ static int write_to_am(int fd, const char* buf, int len) {
		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;
		@@ -46,20 +47,20 @@ static int write_to_am(int fd, const char* buf, int len) {
		return len;
		}

		void _LOG(log_t* log, bool in_tombstone_only, const char *fmt, ...) {
		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;
		int len = 0;

		va_list ap;
		va_start(ap, fmt);

		// where is the information going to go?
		want_tfd_write = log && log->tfd >= 0; // write to the tombstone fd?
		want_log_write = !in_tombstone_only && (!log \|\| !log->quiet);
		want_amfd_write = log && log->amfd >= 0; // only used when want_log_write is true
		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) {
		@@ -78,7 +79,6 @@ void _LOG(log_t* log, bool in_tombstone_only, const char *fmt, ...) {
		int written = write_to_am(log->amfd, buf, len);
		if (written <= 0) {
		// timeout or other failure on write; stop informing the activity manager
		LOG("AM write failure, giving up\n");
		log->amfd = -1;
		}
		}