Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 053b8654 authored by Jeff Brown's avatar Jeff Brown
Browse files

Enhance native stack dumps. 

Provides a new mechanism for dumpstate (while running as root)
to request that debuggerd dump the stacks of native processes that
we care about in bug reports.  In this mode, the backtrace
is formatted to look similar to a Dalvik backtrace.

Moved the tombstone generating code into a separate file to
make it easier to maintain.

Fixed a bug where sometimes the stack traces would be incomplete
because we were not waiting for each thread to stop after issuing
PTRACE_ATTACH, only the main thread.  So sometimes we were missing
traces for some threads.

Refactored the logging code to prevent accidentally writing data
to logcat when explicitly dumping a tombstone or backtrace from the
console.

Only root or system server can request to dump backtraces but
only root can dump tombstones.

Bug: 6615693
Change-Id: Ib3edcc16f9f3a687e414e3f2d250d9500566123b
parent 5f2d00b0

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.