Merge changes from topic 'debuggerd_client'

LOCAL_C_INCLUDES += system/extras/ext4_utils

LOCAL_SANITIZE := $(adb_target_sanitize)

LOCAL_STRIP_MODULE := keep_symbols

LOCAL_STATIC_LIBRARIES := \

    libadbd \

    libbase \

    libbase \

    libcrypto_utils_static \

    libcrypto_static \

    libminijail

    libminijail \

    libdebuggerd_client \

include $(BUILD_EXECUTABLE)

#include <libminijail.h>

#include "cutils/properties.h"

#include "debuggerd/client.h"

#include "private/android_filesystem_config.h"

#include "selinux/android.h"

    close_stdin();

    debuggerd_init(nullptr);

    adb_trace_init(argv);

    D("Handling main()");

cc_library_static {

  name: "libdebuggerd_client",

  srcs: ["client/debuggerd_client.cpp"],

  cflags: [

    "-Wall",

    "-Wextra",

    "-Werror",

    "-Os",

  ],

  local_include_dirs: ["include"],

  export_include_dirs: ["include"],

  // libdebuggerd_client gets async signal safe logging via libc_logging,

  // which defines its interface in bionic private headers.

  include_dirs: ["bionic/libc"],

  static_libs: ["libc_logging"],

}

    -Wunused \

    -Werror \

ifeq ($(TARGET_IS_64_BIT),true)

common_cppflags += -DTARGET_IS_64_BIT

endif

include $(CLEAR_VARS)

LOCAL_SRC_FILES:= \

LOCAL_SRC_FILES_x86    := x86/machine.cpp

LOCAL_SRC_FILES_x86_64 := x86_64/machine.cpp

LOCAL_C_INCLUDES := $(LOCAL_PATH)/include

LOCAL_CPPFLAGS := $(common_cppflags)

LOCAL_INIT_RC_32 := debuggerd.rc

LOCAL_INIT_RC_64 := debuggerd64.rc

ifeq ($(TARGET_IS_64_BIT),true)

LOCAL_CPPFLAGS += -DTARGET_IS_64_BIT

endif

LOCAL_SHARED_LIBRARIES := \

    libbacktrace \

    libbase \

include $(BUILD_EXECUTABLE)

crasher_cppflags := $(common_cppflags) -fstack-protector-all -Wno-free-nonheap-object -Wno-date-time

include $(CLEAR_VARS)

LOCAL_SRC_FILES := crasher.cpp

LOCAL_SRC_FILES_x86_64 := x86_64/crashglue.S

LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)

LOCAL_MODULE_TAGS := optional

LOCAL_CPPFLAGS := $(common_cppflags) -fstack-protector-all -Wno-free-nonheap-object -Wno-date-time

#LOCAL_FORCE_STATIC_EXECUTABLE := true

LOCAL_CPPFLAGS := $(crasher_cppflags)

LOCAL_SHARED_LIBRARIES := libcutils liblog

# The arm emulator has VFP but not VFPv3-D32.

include $(BUILD_EXECUTABLE)

include $(CLEAR_VARS)

LOCAL_SRC_FILES := crasher.cpp

LOCAL_SRC_FILES_arm    := arm/crashglue.S

LOCAL_SRC_FILES_arm64  := arm64/crashglue.S

LOCAL_SRC_FILES_mips   := mips/crashglue.S

LOCAL_SRC_FILES_mips64 := mips64/crashglue.S

LOCAL_SRC_FILES_x86    := x86/crashglue.S

LOCAL_SRC_FILES_x86_64 := x86_64/crashglue.S

LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)

LOCAL_MODULE_TAGS := optional

LOCAL_CPPFLAGS := $(crasher_cppflags) -DSTATIC_CRASHER

LOCAL_FORCE_STATIC_EXECUTABLE := true

LOCAL_SHARED_LIBRARIES := libcutils liblog

# The arm emulator has VFP but not VFPv3-D32.

ifeq ($(ARCH_ARM_HAVE_VFP_D32),true)

LOCAL_ASFLAGS_arm += -DHAS_VFP_D32

endif

LOCAL_MODULE := static_crasher

LOCAL_MODULE_STEM_32 := static_crasher

LOCAL_MODULE_STEM_64 := static_crasher64

LOCAL_MULTILIB := both

LOCAL_STATIC_LIBRARIES := libdebuggerd_client libcutils liblog

include $(BUILD_EXECUTABLE)

debuggerd_test_src_files := \

    utility.cpp \

    test/dump_memory_test.cpp \

/*

 * Copyright (C) 2008 The Android Open Source Project

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *  * Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *  * Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include "debuggerd/client.h"

#include <errno.h>

#include <inttypes.h>

#include <pthread.h>

#include <signal.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mman.h>

#include <sys/prctl.h>

#include <sys/socket.h>

#include <sys/syscall.h>

#include <sys/un.h>

#include <unistd.h>

#include "private/libc_logging.h"

#if defined(TARGET_IS_64_BIT) && !defined(__LP64__)

#define SOCKET_NAME "android:debuggerd32"

#else

#define SOCKET_NAME "android:debuggerd"

#endif

// see man(2) prctl, specifically the section about PR_GET_NAME

#define MAX_TASK_NAME_LEN (16)

static debuggerd_callbacks_t g_callbacks;

static int socket_abstract_client(const char* name, int type) {

  sockaddr_un addr;

  // Test with length +1 for the *initial* '\0'.

  size_t namelen = strlen(name);

  if ((namelen + 1) > sizeof(addr.sun_path)) {

    errno = EINVAL;

    return -1;

  }

  // This is used for abstract socket namespace, we need

  // an initial '\0' at the start of the Unix socket path.

  //

  // Note: The path in this case is *not* supposed to be

  // '\0'-terminated. ("man 7 unix" for the gory details.)

  memset(&addr, 0, sizeof(addr));

  addr.sun_family = AF_LOCAL;

  addr.sun_path[0] = 0;

  memcpy(addr.sun_path + 1, name, namelen);

  socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1;

  int s = socket(AF_LOCAL, type, 0);

  if (s == -1) {

    return -1;

  }

  int rc = TEMP_FAILURE_RETRY(connect(s, reinterpret_cast<sockaddr*>(&addr), alen));

  if (rc == -1) {

    close(s);

    return -1;

  }

  return s;

}

/*

 * Writes a summary of the signal to the log file.  We do this so that, if

 * for some reason we're not able to contact debuggerd, there is still some

 * indication of the failure in the log.

 *

 * We could be here as a result of native heap corruption, or while a

 * mutex is being held, so we don't want to use any libc functions that

 * could allocate memory or hold a lock.

 */

static void log_signal_summary(int signum, const siginfo_t* info) {

  const char* signal_name = "???";

  bool has_address = false;

  switch (signum) {

    case SIGABRT:

      signal_name = "SIGABRT";

      break;

    case SIGBUS:

      signal_name = "SIGBUS";

      has_address = true;

      break;

    case SIGFPE:

      signal_name = "SIGFPE";

      has_address = true;

      break;

    case SIGILL:

      signal_name = "SIGILL";

      has_address = true;

      break;

    case SIGSEGV:

      signal_name = "SIGSEGV";

      has_address = true;

      break;

#if defined(SIGSTKFLT)

    case SIGSTKFLT:

      signal_name = "SIGSTKFLT";

      break;

#endif

    case SIGTRAP:

      signal_name = "SIGTRAP";

      break;

  }

  char thread_name[MAX_TASK_NAME_LEN + 1];  // one more for termination

  if (prctl(PR_GET_NAME, reinterpret_cast<unsigned long>(thread_name), 0, 0, 0) != 0) {

    strcpy(thread_name, "<name unknown>");

  } else {

    // short names are null terminated by prctl, but the man page

    // implies that 16 byte names are not.

    thread_name[MAX_TASK_NAME_LEN] = 0;

  }

  // "info" will be null if the siginfo_t information was not available.

  // Many signals don't have an address or a code.

  char code_desc[32];  // ", code -6"

  char addr_desc[32];  // ", fault addr 0x1234"

  addr_desc[0] = code_desc[0] = 0;

  if (info != nullptr) {

    // For a rethrown signal, this si_code will be right and the one debuggerd shows will

    // always be SI_TKILL.

    __libc_format_buffer(code_desc, sizeof(code_desc), ", code %d", info->si_code);

    if (has_address) {

      __libc_format_buffer(addr_desc, sizeof(addr_desc), ", fault addr %p", info->si_addr);

    }

  }

  __libc_format_log(ANDROID_LOG_FATAL, "libc", "Fatal signal %d (%s)%s%s in tid %d (%s)", signum,

                    signal_name, code_desc, addr_desc, gettid(), thread_name);

}

/*

 * Returns true if the handler for signal "signum" has SA_SIGINFO set.

 */

static bool have_siginfo(int signum) {

  struct sigaction old_action, new_action;

  memset(&new_action, 0, sizeof(new_action));

  new_action.sa_handler = SIG_DFL;

  new_action.sa_flags = SA_RESTART;

  sigemptyset(&new_action.sa_mask);

  if (sigaction(signum, &new_action, &old_action) < 0) {

    __libc_format_log(ANDROID_LOG_WARN, "libc", "Failed testing for SA_SIGINFO: %s",

                      strerror(errno));

    return false;

  }

  bool result = (old_action.sa_flags & SA_SIGINFO) != 0;

  if (sigaction(signum, &old_action, nullptr) == -1) {

    __libc_format_log(ANDROID_LOG_WARN, "libc", "Restore failed in test for SA_SIGINFO: %s",

                      strerror(errno));

  }

  return result;

}

static void send_debuggerd_packet(siginfo_t* info) {

  // Mutex to prevent multiple crashing threads from trying to talk

  // to debuggerd at the same time.

  static pthread_mutex_t crash_mutex = PTHREAD_MUTEX_INITIALIZER;

  int ret = pthread_mutex_trylock(&crash_mutex);

  if (ret != 0) {

    if (ret == EBUSY) {

      __libc_format_log(ANDROID_LOG_INFO, "libc",

                        "Another thread contacted debuggerd first; not contacting debuggerd.");

      // This will never complete since the lock is never released.

      pthread_mutex_lock(&crash_mutex);

    } else {

      __libc_format_log(ANDROID_LOG_INFO, "libc", "pthread_mutex_trylock failed: %s", strerror(ret));

    }

    return;

  }

  int s = socket_abstract_client(SOCKET_NAME, SOCK_STREAM | SOCK_CLOEXEC);

  if (s == -1) {

    __libc_format_log(ANDROID_LOG_FATAL, "libc", "Unable to open connection to debuggerd: %s",

                      strerror(errno));

    return;

  }

  // debuggerd knows our pid from the credentials on the

  // local socket but we need to tell it the tid of the crashing thread.

  // debuggerd will be paranoid and verify that we sent a tid

  // that's actually in our process.

  debugger_msg_t msg;

  msg.action = DEBUGGER_ACTION_CRASH;

  msg.tid = gettid();

  msg.abort_msg_address = 0;

  if (g_callbacks.get_abort_message) {

    msg.abort_msg_address = reinterpret_cast<uintptr_t>(g_callbacks.get_abort_message());

  }

  msg.original_si_code = (info != nullptr) ? info->si_code : 0;

  ret = TEMP_FAILURE_RETRY(write(s, &msg, sizeof(msg)));

  if (ret == sizeof(msg)) {

    char debuggerd_ack;

    ret = TEMP_FAILURE_RETRY(read(s, &debuggerd_ack, 1));

    int saved_errno = errno;

    if (g_callbacks.post_dump) {

      g_callbacks.post_dump();

    }

    errno = saved_errno;

  } else {

    // read or write failed -- broken connection?

    __libc_format_log(ANDROID_LOG_FATAL, "libc", "Failed while talking to debuggerd: %s",

                      strerror(errno));

  }

  close(s);

}

/*

 * Catches fatal signals so we can ask debuggerd to ptrace us before

 * we crash.

 */

static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void*) {

  // It's possible somebody cleared the SA_SIGINFO flag, which would mean

  // our "info" arg holds an undefined value.

  if (!have_siginfo(signal_number)) {

    info = nullptr;

  }

  log_signal_summary(signal_number, info);

  send_debuggerd_packet(info);

  // We need to return from the signal handler so that debuggerd can dump the

  // thread that crashed, but returning here does not guarantee that the signal

  // will be thrown again, even for SIGSEGV and friends, since the signal could

  // have been sent manually. Resend the signal with rt_tgsigqueueinfo(2) to

  // preserve the SA_SIGINFO contents.

  signal(signal_number, SIG_DFL);

  struct siginfo si;

  if (!info) {

    memset(&si, 0, sizeof(si));

    si.si_code = SI_USER;

    si.si_pid = getpid();

    si.si_uid = getuid();

    info = &si;

  } else if (info->si_code >= 0 || info->si_code == SI_TKILL) {

    // rt_tgsigqueueinfo(2)'s documentation appears to be incorrect on kernels

    // that contain commit 66dd34a (3.9+). The manpage claims to only allow

    // negative si_code values that are not SI_TKILL, but 66dd34a changed the

    // check to allow all si_code values in calls coming from inside the house.

  }

  int rc = syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), signal_number, info);

  if (rc != 0) {

    __libc_format_log(ANDROID_LOG_FATAL, "libc", "failed to resend signal during crash: %s",

                      strerror(errno));

    _exit(0);

  }

}

void debuggerd_init(debuggerd_callbacks_t* callbacks) {

  if (callbacks) {

    g_callbacks = *callbacks;

  }

  struct sigaction action;

  memset(&action, 0, sizeof(action));

  sigemptyset(&action.sa_mask);

  action.sa_sigaction = debuggerd_signal_handler;

  action.sa_flags = SA_RESTART | SA_SIGINFO;

  // Use the alternate signal stack if available so we can catch stack overflows.

  action.sa_flags |= SA_ONSTACK;

  sigaction(SIGABRT, &action, nullptr);

  sigaction(SIGBUS, &action, nullptr);

  sigaction(SIGFPE, &action, nullptr);

  sigaction(SIGILL, &action, nullptr);

  sigaction(SIGSEGV, &action, nullptr);

#if defined(SIGSTKFLT)

  sigaction(SIGSTKFLT, &action, nullptr);

#endif

  sigaction(SIGTRAP, &action, nullptr);

}