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

Commit a73df601 authored by Narayan Kamath's avatar Narayan Kamath
Browse files

tombstoned: allow intercepts for java traces. 

All intercept requests and crash dump requests must now specify a
dump_type, which can be one of kDebuggerdNativeBacktrace,
kDebuggerdTombstone or kDebuggerdJavaBacktrace. Each process can have
only one outstanding intercept registered at a time.

There's only one non-trivial change in this changeset; and that is
to crash_dump. We now pass the type of dump via a command line
argument instead of inferring it from the (resent) signal, this allows
us to connect to tombstoned before we wait for the signal as the
protocol requires.

Test: debuggerd_test

Change-Id: I189b215acfecd08ac52ab29117e3465da00e3a37
parent 844940d7

debuggerd/Android.bp

+23 −3
Original line number Diff line number Diff line
@@ -11,6 +11,11 @@ cc_defaults { 
    local_include_dirs: ["include"],

}



cc_library_headers {

    name: "libdebuggerd_common_headers",

    export_include_dirs: ["common/include"]

}



cc_library_shared {

    name: "libtombstoned_client",

    defaults: ["debuggerd_defaults"],
@@ -19,15 +24,18 @@ cc_library_shared { 
        "util.cpp",

    ],



    header_libs: ["libdebuggerd_common_headers"],



    static_libs: [

        "libasync_safe"

        "libasync_safe",

    ],



    shared_libs: [

        "libcutils",

        "libbase",

        "libcutils",

    ],



    export_header_lib_headers: ["libdebuggerd_common_headers"],

    export_include_dirs: ["tombstoned/include"]

}
@@ -40,12 +48,15 @@ cc_library_static { 
        "util.cpp",

    ],



    header_libs: ["libdebuggerd_common_headers"],



    whole_static_libs: [

        "libasync_safe",

        "libcutils",

        "libbase",

    ],



    export_header_lib_headers: ["libdebuggerd_common_headers"],

    export_include_dirs: ["tombstoned/include"]

}
@@ -55,11 +66,14 @@ cc_library_static { 
    defaults: ["debuggerd_defaults"],

    srcs: ["handler/debuggerd_handler.cpp"],



    header_libs: ["libdebuggerd_common_headers"],



    whole_static_libs: [

        "libasync_safe",

        "libdebuggerd",

    ],



    export_header_lib_headers: ["libdebuggerd_common_headers"],

    export_include_dirs: ["include"],

}
@@ -107,11 +121,14 @@ cc_library { 
        "util.cpp",

    ],



    header_libs: ["libdebuggerd_common_headers"],



    shared_libs: [

        "libbase",

        "libcutils",

    ],



    export_header_lib_headers: ["libdebuggerd_common_headers"],

    export_include_dirs: ["include"],

}
@@ -191,7 +208,8 @@ cc_test { 
        "libbase",

        "libcutils",

        "libdebuggerd_client",

        "liblog"

        "liblog",

        "libnativehelper"

    ],



    static_libs: [
@@ -271,6 +289,8 @@ cc_binary { 
    ],

    defaults: ["debuggerd_defaults"],



    header_libs: ["libdebuggerd_common_headers"],



    static_libs: [

        "libbase",

        "libcutils",

debuggerd/client/debuggerd_client.cpp

+14 −12
Original line number Diff line number Diff line
@@ -40,10 +40,12 @@ using namespace std::chrono_literals; 


using android::base::unique_fd;



static bool send_signal(pid_t pid, bool backtrace) {

static bool send_signal(pid_t pid, const DebuggerdDumpType dump_type) {

  const int signal = (dump_type == kDebuggerdJavaBacktrace) ? SIGQUIT : DEBUGGER_SIGNAL;

  sigval val;

  val.sival_int = backtrace;

  if (sigqueue(pid, DEBUGGER_SIGNAL, val) != 0) {

  val.sival_int = (dump_type == kDebuggerdNativeBacktrace) ? 1 : 0;



  if (sigqueue(pid, signal, val) != 0) {

    PLOG(ERROR) << "libdebuggerd_client: failed to send signal to pid " << pid;

    return false;

  }
@@ -58,8 +60,8 @@ static void populate_timeval(struct timeval* tv, const Duration& duration) { 
  tv->tv_usec = static_cast<long>(microseconds.count());

}



bool debuggerd_trigger_dump(pid_t pid, unique_fd output_fd, DebuggerdDumpType dump_type,

                            unsigned int timeout_ms) {

bool debuggerd_trigger_dump(pid_t pid, DebuggerdDumpType dump_type, unsigned int timeout_ms,

                            unique_fd output_fd) {

  LOG(INFO) << "libdebuggerd_client: started dumping process " << pid;

  unique_fd sockfd;

  const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
@@ -102,7 +104,7 @@ bool debuggerd_trigger_dump(pid_t pid, unique_fd output_fd, DebuggerdDumpType du 
    return false;

  }



  InterceptRequest req = {.pid = pid };

  InterceptRequest req = {.pid = pid, .dump_type = dump_type};

  if (!set_timeout(sockfd)) {

    PLOG(ERROR) << "libdebugger_client: failed to set timeout";

    return false;
@@ -140,8 +142,7 @@ bool debuggerd_trigger_dump(pid_t pid, unique_fd output_fd, DebuggerdDumpType du 
    return false;

  }



  bool backtrace = dump_type == kDebuggerdBacktrace;

  if (!send_signal(pid, backtrace)) {

  if (!send_signal(pid, dump_type)) {

    return false;

  }
@@ -210,15 +211,16 @@ bool debuggerd_trigger_dump(pid_t pid, unique_fd output_fd, DebuggerdDumpType du 
  return true;

}



int dump_backtrace_to_file(pid_t tid, int fd) {

  return dump_backtrace_to_file_timeout(tid, fd, 0);

int dump_backtrace_to_file(pid_t tid, DebuggerdDumpType dump_type, int fd) {

  return dump_backtrace_to_file_timeout(tid, dump_type, 0, fd);

}



int dump_backtrace_to_file_timeout(pid_t tid, int fd, int timeout_secs) {

int dump_backtrace_to_file_timeout(pid_t tid, DebuggerdDumpType dump_type, int timeout_secs,

                                   int fd) {

  android::base::unique_fd copy(dup(fd));

  if (copy == -1) {

    return -1;

  }

  int timeout_ms = timeout_secs > 0 ? timeout_secs * 1000 : 0;

  return debuggerd_trigger_dump(tid, std::move(copy), kDebuggerdBacktrace, timeout_ms) ? 0 : -1;

  return debuggerd_trigger_dump(tid, dump_type, timeout_ms, std::move(copy)) ? 0 : -1;

}

debuggerd/client/debuggerd_client_test.cpp

+4 −2
Original line number Diff line number Diff line
@@ -67,7 +67,8 @@ TEST(debuggerd_client, race) { 
  // Wait for a bit to let the child spawn all of its threads.

  std::this_thread::sleep_for(250ms);



  ASSERT_TRUE(debuggerd_trigger_dump(forkpid, std::move(pipe_write), kDebuggerdBacktrace, 10000));

  ASSERT_TRUE(

      debuggerd_trigger_dump(forkpid, kDebuggerdNativeBacktrace, 10000, std::move(pipe_write)));

  // Immediately kill the forked child, to make sure that the dump didn't return early.

  ASSERT_EQ(0, kill(forkpid, SIGKILL)) << strerror(errno);
@@ -107,5 +108,6 @@ TEST(debuggerd_client, no_timeout) { 


  unique_fd output_read, output_write;

  ASSERT_TRUE(Pipe(&output_read, &output_write));

  ASSERT_TRUE(debuggerd_trigger_dump(forkpid, std::move(output_write), kDebuggerdBacktrace, 0));

  ASSERT_TRUE(

      debuggerd_trigger_dump(forkpid, kDebuggerdNativeBacktrace, 0, std::move(output_write)));

}

debuggerd/common/include/dump_type.h

0 → 100644
+49 −0
Original line number Diff line number Diff line 
#pragma once



/*

 * Copyright 2017, 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 <sys/types.h>



#include <ostream>



enum DebuggerdDumpType : uint8_t {

  kDebuggerdNativeBacktrace,

  kDebuggerdTombstone,

  kDebuggerdJavaBacktrace,

  kDebuggerdAnyIntercept

};



inline std::ostream& operator<<(std::ostream& stream, const DebuggerdDumpType& rhs) {

  switch (rhs) {

    case kDebuggerdNativeBacktrace:

      stream << "kDebuggerdNativeBacktrace";

      break;

    case kDebuggerdTombstone:

      stream << "kDebuggerdTombstone";

      break;

    case kDebuggerdJavaBacktrace:

      stream << "kDebuggerdJavaBacktrace";

      break;

    case kDebuggerdAnyIntercept:

      stream << "kDebuggerdAnyIntercept";

      break;

    default:

      stream << "[unknown]";

  }



  return stream;

}

debuggerd/crash_dump.cpp

+12 −5
Original line number Diff line number Diff line
@@ -150,13 +150,13 @@ static void signal_handler(int) { 
  _exit(1);

}



static void abort_handler(pid_t target, const bool& tombstoned_connected,

static void abort_handler(pid_t target, const bool tombstoned_connected,

                          unique_fd& tombstoned_socket, unique_fd& output_fd,

                          const char* abort_msg) {

  // If we abort before we get an output fd, contact tombstoned to let any

  // potential listeners know that we failed.

  if (!tombstoned_connected) {

    if (!tombstoned_connect(target, &tombstoned_socket, &output_fd)) {

    if (!tombstoned_connect(target, &tombstoned_socket, &output_fd, kDebuggerdAnyIntercept)) {

      // We failed to connect, not much we can do.

      LOG(ERROR) << "failed to connected to tombstoned to report failure";

      _exit(1);
@@ -207,12 +207,14 @@ int main(int argc, char** argv) { 
  action.sa_handler = signal_handler;

  debuggerd_register_handlers(&action);



  if (argc != 3) {

  if (argc != 4) {

    LOG(FATAL) << "Wrong number of args: " << argc << " (expected 4)";

    return 1;

  }



  pid_t main_tid;

  pid_t pseudothread_tid;

  int dump_type;



  if (!android::base::ParseInt(argv[1], &main_tid, 1, std::numeric_limits<pid_t>::max())) {

    LOG(FATAL) << "invalid main tid: " << argv[1];
@@ -222,6 +224,10 @@ int main(int argc, char** argv) { 
    LOG(FATAL) << "invalid pseudothread tid: " << argv[2];

  }



  if (!android::base::ParseInt(argv[3], &dump_type, 0, 1)) {

    LOG(FATAL) << "invalid requested dump type: " << argv[3];

  }



  if (target == 1) {

    LOG(FATAL) << "target died before we could attach (received main tid = " << main_tid << ")";

  }
@@ -305,8 +311,9 @@ int main(int argc, char** argv) { 
  // Drop our capabilities now that we've attached to the threads we care about.

  drop_capabilities();



  LOG(INFO) << "obtaining output fd from tombstoned";

  tombstoned_connected = tombstoned_connect(target, &tombstoned_socket, &output_fd);

  const DebuggerdDumpType dump_type_enum = static_cast<DebuggerdDumpType>(dump_type);

  LOG(INFO) << "obtaining output fd from tombstoned, type: " << dump_type_enum;

  tombstoned_connected = tombstoned_connect(target, &tombstoned_socket, &output_fd, dump_type_enum);



  // Write a '\1' to stdout to tell the crashing process to resume.

  // It also restores the value of PR_SET_DUMPABLE at this point.