Reland protobuf tombstones.
This reverts the following commits:
e156ede145a7fc671c705d045d89b49922a758b5.
eda96eddcbdda9632166232b2363c7b84da0994d.
5ec54d1e843729cd1e38a2f791f001226a653e95.
1e45d3f2239333217d3252f78151f4294fda4e80.
a50f61f8fa903117a6df82d164628de310f16ae9.
Test: treehugger
Test: atest -c CtsSeccompHostTestCases:android.seccomp.cts.SeccompHostJUnit4DeviceTest#testAppZygoteSyscalls
Change-Id: Ic2b1f489ac9f1fec7d7a33c845c29891f4306bbd
diff --git a/debuggerd/tombstoned/include/tombstoned/tombstoned.h b/debuggerd/tombstoned/include/tombstoned/tombstoned.h
index 6403dbe..bff216c 100644
--- a/debuggerd/tombstoned/include/tombstoned/tombstoned.h
+++ b/debuggerd/tombstoned/include/tombstoned/tombstoned.h
@@ -23,6 +23,10 @@
#include "dump_type.h"
bool tombstoned_connect(pid_t pid, android::base::unique_fd* tombstoned_socket,
- android::base::unique_fd* output_fd, DebuggerdDumpType dump_type);
+ android::base::unique_fd* text_output_fd,
+ android::base::unique_fd* proto_output_fd, DebuggerdDumpType dump_type);
+
+bool tombstoned_connect(pid_t pid, android::base::unique_fd* tombstoned_socket,
+ android::base::unique_fd* text_output_fd, DebuggerdDumpType dump_type);
bool tombstoned_notify_completion(int tombstoned_socket);
diff --git a/debuggerd/tombstoned/intercept_manager.cpp b/debuggerd/tombstoned/intercept_manager.cpp
index 6cbf12c..437639e 100644
--- a/debuggerd/tombstoned/intercept_manager.cpp
+++ b/debuggerd/tombstoned/intercept_manager.cpp
@@ -191,6 +191,18 @@
/* backlog */ -1, intercept_socket);
}
+bool dump_types_compatible(DebuggerdDumpType interceptor, DebuggerdDumpType dump) {
+ if (interceptor == dump) {
+ return true;
+ }
+
+ if (interceptor == kDebuggerdTombstone && dump == kDebuggerdTombstoneProto) {
+ return true;
+ }
+
+ return false;
+}
+
bool InterceptManager::GetIntercept(pid_t pid, DebuggerdDumpType dump_type,
android::base::unique_fd* out_fd) {
auto it = this->intercepts.find(pid);
@@ -201,7 +213,7 @@
if (dump_type == kDebuggerdAnyIntercept) {
LOG(INFO) << "found registered intercept of type " << it->second->dump_type
<< " for requested type kDebuggerdAnyIntercept";
- } else if (it->second->dump_type != dump_type) {
+ } else if (!dump_types_compatible(it->second->dump_type, dump_type)) {
LOG(WARNING) << "found non-matching intercept of type " << it->second->dump_type
<< " for requested type: " << dump_type;
return false;
diff --git a/debuggerd/tombstoned/tombstoned.cpp b/debuggerd/tombstoned/tombstoned.cpp
index d09b8e8..f057260 100644
--- a/debuggerd/tombstoned/tombstoned.cpp
+++ b/debuggerd/tombstoned/tombstoned.cpp
@@ -48,6 +48,8 @@
using android::base::GetIntProperty;
using android::base::SendFileDescriptors;
using android::base::StringPrintf;
+
+using android::base::borrowed_fd;
using android::base::unique_fd;
static InterceptManager* intercept_manager;
@@ -57,14 +59,34 @@
kCrashStatusQueued,
};
+struct CrashArtifact {
+ unique_fd fd;
+ std::optional<std::string> temporary_path;
+
+ static CrashArtifact devnull() {
+ CrashArtifact result;
+ result.fd.reset(open("/dev/null", O_WRONLY | O_CLOEXEC));
+ return result;
+ }
+};
+
+struct CrashArtifactPaths {
+ std::string text;
+ std::optional<std::string> proto;
+};
+
+struct CrashOutput {
+ CrashArtifact text;
+ std::optional<CrashArtifact> proto;
+};
+
// Ownership of Crash is a bit messy.
// It's either owned by an active event that must have a timeout, or owned by
// queued_requests, in the case that multiple crashes come in at the same time.
struct Crash {
~Crash() { event_free(crash_event); }
- std::string crash_tombstone_path;
- unique_fd crash_tombstone_fd;
+ CrashOutput output;
unique_fd crash_socket_fd;
pid_t crash_pid;
event* crash_event = nullptr;
@@ -75,14 +97,15 @@
class CrashQueue {
public:
CrashQueue(const std::string& dir_path, const std::string& file_name_prefix, size_t max_artifacts,
- size_t max_concurrent_dumps)
+ size_t max_concurrent_dumps, bool supports_proto)
: file_name_prefix_(file_name_prefix),
dir_path_(dir_path),
dir_fd_(open(dir_path.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC)),
max_artifacts_(max_artifacts),
next_artifact_(0),
max_concurrent_dumps_(max_concurrent_dumps),
- num_concurrent_dumps_(0) {
+ num_concurrent_dumps_(0),
+ supports_proto_(supports_proto) {
if (dir_fd_ == -1) {
PLOG(FATAL) << "failed to open directory: " << dir_path;
}
@@ -98,59 +121,104 @@
return (crash->crash_type == kDebuggerdJavaBacktrace) ? for_anrs() : for_tombstones();
}
+ static CrashQueue* for_crash(const std::unique_ptr<Crash>& crash) {
+ return for_crash(crash.get());
+ }
+
static CrashQueue* for_tombstones() {
static CrashQueue queue("/data/tombstones", "tombstone_" /* file_name_prefix */,
GetIntProperty("tombstoned.max_tombstone_count", 32),
- 1 /* max_concurrent_dumps */);
+ 1 /* max_concurrent_dumps */, true /* supports_proto */);
return &queue;
}
static CrashQueue* for_anrs() {
static CrashQueue queue("/data/anr", "trace_" /* file_name_prefix */,
GetIntProperty("tombstoned.max_anr_count", 64),
- 4 /* max_concurrent_dumps */);
+ 4 /* max_concurrent_dumps */, false /* supports_proto */);
return &queue;
}
- std::pair<std::string, unique_fd> get_output() {
- std::string path;
- unique_fd result(openat(dir_fd_, ".", O_WRONLY | O_APPEND | O_TMPFILE | O_CLOEXEC, 0640));
- if (result == -1) {
+ CrashArtifact create_temporary_file() const {
+ CrashArtifact result;
+
+ std::optional<std::string> path;
+ result.fd.reset(openat(dir_fd_, ".", O_WRONLY | O_APPEND | O_TMPFILE | O_CLOEXEC, 0640));
+ if (result.fd == -1) {
// We might not have O_TMPFILE. Try creating with an arbitrary filename instead.
static size_t counter = 0;
std::string tmp_filename = StringPrintf(".temporary%zu", counter++);
- result.reset(openat(dir_fd_, tmp_filename.c_str(),
- O_WRONLY | O_APPEND | O_CREAT | O_TRUNC | O_CLOEXEC, 0640));
- if (result == -1) {
+ result.fd.reset(openat(dir_fd_, tmp_filename.c_str(),
+ O_WRONLY | O_APPEND | O_CREAT | O_TRUNC | O_CLOEXEC, 0640));
+ if (result.fd == -1) {
PLOG(FATAL) << "failed to create temporary tombstone in " << dir_path_;
}
- path = StringPrintf("%s/%s", dir_path_.c_str(), tmp_filename.c_str());
+ result.temporary_path = std::move(tmp_filename);
}
- return std::make_pair(std::move(path), std::move(result));
+
+ return std::move(result);
}
- std::string get_next_artifact_path() {
- std::string file_name =
- StringPrintf("%s/%s%02d", dir_path_.c_str(), file_name_prefix_.c_str(), next_artifact_);
+ std::optional<CrashOutput> get_output(DebuggerdDumpType dump_type) {
+ CrashOutput result;
+
+ switch (dump_type) {
+ case kDebuggerdNativeBacktrace:
+ case kDebuggerdJavaBacktrace:
+ // Don't generate tombstones for backtrace requests.
+ return {};
+
+ case kDebuggerdTombstoneProto:
+ if (!supports_proto_) {
+ LOG(ERROR) << "received kDebuggerdTombstoneProto on a queue that doesn't support proto";
+ return {};
+ }
+ result.proto = create_temporary_file();
+ result.text = create_temporary_file();
+ break;
+
+ case kDebuggerdTombstone:
+ result.text = create_temporary_file();
+ break;
+
+ default:
+ LOG(ERROR) << "unexpected dump type: " << dump_type;
+ return {};
+ }
+
+ return result;
+ }
+
+ borrowed_fd dir_fd() { return dir_fd_; }
+
+ CrashArtifactPaths get_next_artifact_paths() {
+ CrashArtifactPaths result;
+ result.text = StringPrintf("%s%02d", file_name_prefix_.c_str(), next_artifact_);
+
+ if (supports_proto_) {
+ result.proto = StringPrintf("%s%02d.pb", file_name_prefix_.c_str(), next_artifact_);
+ }
+
next_artifact_ = (next_artifact_ + 1) % max_artifacts_;
- return file_name;
+ return result;
}
- bool maybe_enqueue_crash(Crash* crash) {
+ // Consumes crash if it returns true, otherwise leaves it untouched.
+ bool maybe_enqueue_crash(std::unique_ptr<Crash>&& crash) {
if (num_concurrent_dumps_ == max_concurrent_dumps_) {
- queued_requests_.push_back(crash);
+ queued_requests_.emplace_back(std::move(crash));
return true;
}
return false;
}
- void maybe_dequeue_crashes(void (*handler)(Crash* crash)) {
+ void maybe_dequeue_crashes(void (*handler)(std::unique_ptr<Crash> crash)) {
while (!queued_requests_.empty() && num_concurrent_dumps_ < max_concurrent_dumps_) {
- Crash* next_crash = queued_requests_.front();
+ std::unique_ptr<Crash> next_crash = std::move(queued_requests_.front());
queued_requests_.pop_front();
- handler(next_crash);
+ handler(std::move(next_crash));
}
}
@@ -164,7 +232,8 @@
time_t oldest_time = std::numeric_limits<time_t>::max();
for (size_t i = 0; i < max_artifacts_; ++i) {
- std::string path = StringPrintf("%s/%s%02zu", dir_path_.c_str(), file_name_prefix_.c_str(), i);
+ std::string path =
+ StringPrintf("%s/%s%02zu", dir_path_.c_str(), file_name_prefix_.c_str(), i);
struct stat st;
if (stat(path.c_str(), &st) != 0) {
if (errno == ENOENT) {
@@ -196,7 +265,9 @@
const size_t max_concurrent_dumps_;
size_t num_concurrent_dumps_;
- std::deque<Crash*> queued_requests_;
+ bool supports_proto_;
+
+ std::deque<std::unique_ptr<Crash>> queued_requests_;
DISALLOW_COPY_AND_ASSIGN(CrashQueue);
};
@@ -205,52 +276,61 @@
static constexpr bool kJavaTraceDumpsEnabled = true;
// Forward declare the callbacks so they can be placed in a sensible order.
-static void crash_accept_cb(evconnlistener* listener, evutil_socket_t sockfd, sockaddr*, int, void*);
+static void crash_accept_cb(evconnlistener* listener, evutil_socket_t sockfd, sockaddr*, int,
+ void*);
static void crash_request_cb(evutil_socket_t sockfd, short ev, void* arg);
static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg);
-static void perform_request(Crash* crash) {
+static void perform_request(std::unique_ptr<Crash> crash) {
unique_fd output_fd;
bool intercepted =
intercept_manager->GetIntercept(crash->crash_pid, crash->crash_type, &output_fd);
- if (!intercepted) {
- if (crash->crash_type == kDebuggerdNativeBacktrace) {
- // Don't generate tombstones for native backtrace requests.
- output_fd.reset(open("/dev/null", O_WRONLY | O_CLOEXEC));
+ if (intercepted) {
+ if (crash->crash_type == kDebuggerdTombstoneProto) {
+ crash->output.proto = CrashArtifact::devnull();
+ }
+ } else {
+ if (auto o = CrashQueue::for_crash(crash.get())->get_output(crash->crash_type); o) {
+ crash->output = std::move(*o);
+ output_fd.reset(dup(crash->output.text.fd));
} else {
- std::tie(crash->crash_tombstone_path, output_fd) = CrashQueue::for_crash(crash)->get_output();
- crash->crash_tombstone_fd.reset(dup(output_fd.get()));
+ LOG(ERROR) << "failed to get crash output for type " << crash->crash_type;
+ return;
}
}
- TombstonedCrashPacket response = {
- .packet_type = CrashPacketType::kPerformDump
- };
- ssize_t rc =
- SendFileDescriptors(crash->crash_socket_fd, &response, sizeof(response), output_fd.get());
+ TombstonedCrashPacket response = {.packet_type = CrashPacketType::kPerformDump};
+
+ ssize_t rc = -1;
+ if (crash->output.proto) {
+ rc = SendFileDescriptors(crash->crash_socket_fd, &response, sizeof(response), output_fd.get(),
+ crash->output.proto->fd.get());
+ } else {
+ rc = SendFileDescriptors(crash->crash_socket_fd, &response, sizeof(response), output_fd.get());
+ }
+
output_fd.reset();
if (rc == -1) {
PLOG(WARNING) << "failed to send response to CrashRequest";
- goto fail;
+ return;
} else if (rc != sizeof(response)) {
PLOG(WARNING) << "crash socket write returned short";
- goto fail;
- } else {
- // TODO: Make this configurable by the interceptor?
- struct timeval timeout = { 10, 0 };
-
- event_base* base = event_get_base(crash->crash_event);
- event_assign(crash->crash_event, base, crash->crash_socket_fd, EV_TIMEOUT | EV_READ,
- crash_completed_cb, crash);
- event_add(crash->crash_event, &timeout);
+ return;
}
- CrashQueue::for_crash(crash)->on_crash_started();
- return;
+ // TODO: Make this configurable by the interceptor?
+ struct timeval timeout = {10, 0};
-fail:
- delete crash;
+ event_base* base = event_get_base(crash->crash_event);
+
+ event_assign(crash->crash_event, base, crash->crash_socket_fd, EV_TIMEOUT | EV_READ,
+ crash_completed_cb, crash.get());
+ event_add(crash->crash_event, &timeout);
+ CrashQueue::for_crash(crash)->on_crash_started();
+
+ // The crash is now owned by the event loop.
+ crash.release();
}
static void crash_accept_cb(evconnlistener* listener, evutil_socket_t sockfd, sockaddr*, int,
@@ -268,39 +348,37 @@
}
static void crash_request_cb(evutil_socket_t sockfd, short ev, void* arg) {
- ssize_t rc;
- Crash* crash = static_cast<Crash*>(arg);
-
+ std::unique_ptr<Crash> crash(static_cast<Crash*>(arg));
TombstonedCrashPacket request = {};
if ((ev & EV_TIMEOUT) != 0) {
LOG(WARNING) << "crash request timed out";
- goto fail;
+ return;
} else if ((ev & EV_READ) == 0) {
LOG(WARNING) << "tombstoned received unexpected event from crash socket";
- goto fail;
+ return;
}
- rc = TEMP_FAILURE_RETRY(read(sockfd, &request, sizeof(request)));
+ ssize_t rc = TEMP_FAILURE_RETRY(read(sockfd, &request, sizeof(request)));
if (rc == -1) {
PLOG(WARNING) << "failed to read from crash socket";
- goto fail;
+ return;
} else if (rc != sizeof(request)) {
LOG(WARNING) << "crash socket received short read of length " << rc << " (expected "
<< sizeof(request) << ")";
- goto fail;
+ return;
}
if (request.packet_type != CrashPacketType::kDumpRequest) {
LOG(WARNING) << "unexpected crash packet type, expected kDumpRequest, received "
<< StringPrintf("%#2hhX", request.packet_type);
- goto fail;
+ return;
}
crash->crash_type = request.packet.dump_request.dump_type;
- if (crash->crash_type < 0 || crash->crash_type > kDebuggerdAnyIntercept) {
+ if (crash->crash_type < 0 || crash->crash_type > kDebuggerdTombstoneProto) {
LOG(WARNING) << "unexpected crash dump type: " << crash->crash_type;
- goto fail;
+ return;
}
if (crash->crash_type != kDebuggerdJavaBacktrace) {
@@ -314,90 +392,117 @@
int ret = getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
if (ret != 0) {
PLOG(ERROR) << "Failed to getsockopt(..SO_PEERCRED)";
- goto fail;
+ return;
}
crash->crash_pid = cr.pid;
}
- LOG(INFO) << "received crash request for pid " << crash->crash_pid;
+ pid_t crash_pid = crash->crash_pid;
+ LOG(INFO) << "received crash request for pid " << crash_pid;
- if (CrashQueue::for_crash(crash)->maybe_enqueue_crash(crash)) {
- LOG(INFO) << "enqueueing crash request for pid " << crash->crash_pid;
+ if (CrashQueue::for_crash(crash)->maybe_enqueue_crash(std::move(crash))) {
+ LOG(INFO) << "enqueueing crash request for pid " << crash_pid;
} else {
- perform_request(crash);
+ perform_request(std::move(crash));
}
-
- return;
-
-fail:
- delete crash;
}
-static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg) {
- ssize_t rc;
- Crash* crash = static_cast<Crash*>(arg);
- TombstonedCrashPacket request = {};
+static bool link_fd(borrowed_fd fd, borrowed_fd dirfd, const std::string& path) {
+ std::string fd_path = StringPrintf("/proc/self/fd/%d", fd.get());
- CrashQueue::for_crash(crash)->on_crash_completed();
-
- if ((ev & EV_READ) == 0) {
- goto fail;
+ int rc = linkat(AT_FDCWD, fd_path.c_str(), dirfd.get(), path.c_str(), AT_SYMLINK_FOLLOW);
+ if (rc != 0) {
+ PLOG(ERROR) << "failed to link file descriptor";
+ return false;
}
+ return true;
+}
- rc = TEMP_FAILURE_RETRY(read(sockfd, &request, sizeof(request)));
+static void crash_completed(borrowed_fd sockfd, std::unique_ptr<Crash> crash) {
+ TombstonedCrashPacket request = {};
+ CrashQueue* queue = CrashQueue::for_crash(crash);
+
+ ssize_t rc = TEMP_FAILURE_RETRY(read(sockfd.get(), &request, sizeof(request)));
if (rc == -1) {
PLOG(WARNING) << "failed to read from crash socket";
- goto fail;
+ return;
} else if (rc != sizeof(request)) {
LOG(WARNING) << "crash socket received short read of length " << rc << " (expected "
<< sizeof(request) << ")";
- goto fail;
+ return;
}
if (request.packet_type != CrashPacketType::kCompletedDump) {
LOG(WARNING) << "unexpected crash packet type, expected kCompletedDump, received "
<< uint32_t(request.packet_type);
- goto fail;
+ return;
}
- if (crash->crash_tombstone_fd != -1) {
- std::string fd_path = StringPrintf("/proc/self/fd/%d", crash->crash_tombstone_fd.get());
- std::string tombstone_path = CrashQueue::for_crash(crash)->get_next_artifact_path();
+ if (crash->output.text.fd == -1) {
+ LOG(WARNING) << "missing output fd";
+ return;
+ }
- // linkat doesn't let us replace a file, so we need to unlink first.
- int rc = unlink(tombstone_path.c_str());
- if (rc != 0 && errno != ENOENT) {
- PLOG(ERROR) << "failed to unlink tombstone at " << tombstone_path;
- goto fail;
- }
+ CrashArtifactPaths paths = queue->get_next_artifact_paths();
- rc = linkat(AT_FDCWD, fd_path.c_str(), AT_FDCWD, tombstone_path.c_str(), AT_SYMLINK_FOLLOW);
- if (rc != 0) {
- PLOG(ERROR) << "failed to link tombstone";
+ // Always try to unlink the tombstone file.
+ // linkat doesn't let us replace a file, so we need to unlink before linking
+ // our results onto disk, and if we fail for some reason, we should delete
+ // stale tombstones to avoid confusing inconsistency.
+ rc = unlinkat(queue->dir_fd().get(), paths.text.c_str(), 0);
+ if (rc != 0 && errno != ENOENT) {
+ PLOG(ERROR) << "failed to unlink tombstone at " << paths.text;
+ return;
+ }
+
+ if (crash->output.text.fd != -1) {
+ if (!link_fd(crash->output.text.fd, queue->dir_fd(), paths.text)) {
+ LOG(ERROR) << "failed to link tombstone";
} else {
if (crash->crash_type == kDebuggerdJavaBacktrace) {
- LOG(ERROR) << "Traces for pid " << crash->crash_pid << " written to: " << tombstone_path;
+ LOG(ERROR) << "Traces for pid " << crash->crash_pid << " written to: " << paths.text;
} else {
// NOTE: Several tools parse this log message to figure out where the
// tombstone associated with a given native crash was written. Any changes
// to this message must be carefully considered.
- LOG(ERROR) << "Tombstone written to: " << tombstone_path;
- }
- }
-
- // If we don't have O_TMPFILE, we need to clean up after ourselves.
- if (!crash->crash_tombstone_path.empty()) {
- rc = unlink(crash->crash_tombstone_path.c_str());
- if (rc != 0) {
- PLOG(ERROR) << "failed to unlink temporary tombstone at " << crash->crash_tombstone_path;
+ LOG(ERROR) << "Tombstone written to: " << paths.text;
}
}
}
-fail:
+ if (crash->output.proto && crash->output.proto->fd != -1) {
+ if (!paths.proto) {
+ LOG(ERROR) << "missing path for proto tombstone";
+ } else if (!link_fd(crash->output.proto->fd, queue->dir_fd(), *paths.proto)) {
+ LOG(ERROR) << "failed to link proto tombstone";
+ }
+ }
+
+ // If we don't have O_TMPFILE, we need to clean up after ourselves.
+ if (crash->output.text.temporary_path) {
+ rc = unlinkat(queue->dir_fd().get(), crash->output.text.temporary_path->c_str(), 0);
+ if (rc != 0) {
+ PLOG(ERROR) << "failed to unlink temporary tombstone at " << paths.text;
+ }
+ }
+ if (crash->output.proto && crash->output.proto->temporary_path) {
+ rc = unlinkat(queue->dir_fd().get(), crash->output.proto->temporary_path->c_str(), 0);
+ if (rc != 0) {
+ PLOG(ERROR) << "failed to unlink temporary proto tombstone";
+ }
+ }
+}
+
+static void crash_completed_cb(evutil_socket_t sockfd, short ev, void* arg) {
+ std::unique_ptr<Crash> crash(static_cast<Crash*>(arg));
CrashQueue* queue = CrashQueue::for_crash(crash);
- delete crash;
+
+ queue->on_crash_completed();
+
+ if ((ev & EV_READ) == EV_READ) {
+ crash_completed(sockfd, std::move(crash));
+ }
// If there's something queued up, let them proceed.
queue->maybe_dequeue_crashes(perform_request);
diff --git a/debuggerd/tombstoned/tombstoned_client.cpp b/debuggerd/tombstoned/tombstoned_client.cpp
index 2c23c98..abfafb1 100644
--- a/debuggerd/tombstoned/tombstoned_client.cpp
+++ b/debuggerd/tombstoned/tombstoned_client.cpp
@@ -32,8 +32,13 @@
using android::base::ReceiveFileDescriptors;
using android::base::unique_fd;
-bool tombstoned_connect(pid_t pid, unique_fd* tombstoned_socket, unique_fd* output_fd,
+bool tombstoned_connect(pid_t pid, unique_fd* tombstoned_socket, unique_fd* text_output_fd,
DebuggerdDumpType dump_type) {
+ return tombstoned_connect(pid, tombstoned_socket, text_output_fd, nullptr, dump_type);
+}
+
+bool tombstoned_connect(pid_t pid, unique_fd* tombstoned_socket, unique_fd* text_output_fd,
+ unique_fd* proto_output_fd, DebuggerdDumpType dump_type) {
unique_fd sockfd(
socket_local_client((dump_type != kDebuggerdJavaBacktrace ? kTombstonedCrashSocketName
: kTombstonedJavaTraceSocketName),
@@ -54,8 +59,15 @@
return false;
}
- unique_fd tmp_output_fd;
- ssize_t rc = ReceiveFileDescriptors(sockfd, &packet, sizeof(packet), &tmp_output_fd);
+ unique_fd tmp_output_fd, tmp_proto_fd;
+ ssize_t rc = -1;
+
+ if (dump_type == kDebuggerdTombstoneProto) {
+ rc = ReceiveFileDescriptors(sockfd, &packet, sizeof(packet), &tmp_output_fd, &tmp_proto_fd);
+ } else {
+ rc = ReceiveFileDescriptors(sockfd, &packet, sizeof(packet), &tmp_output_fd);
+ }
+
if (rc == -1) {
async_safe_format_log(ANDROID_LOG_ERROR, "libc",
"failed to read response to DumpRequest packet: %s", strerror(errno));
@@ -78,7 +90,10 @@
}
*tombstoned_socket = std::move(sockfd);
- *output_fd = std::move(tmp_output_fd);
+ *text_output_fd = std::move(tmp_output_fd);
+ if (proto_output_fd) {
+ *proto_output_fd = std::move(tmp_proto_fd);
+ }
return true;
}