debuggerd/client/debuggerd_client.cpp - android-core - Git at Google

 /*
  * Copyright 2016, 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 <debuggerd/client.h>

 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/poll.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include <chrono>

 #include <android-base/cmsg.h>
 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <cutils/sockets.h>
 #include <procinfo/process.h>

 #include "debuggerd/handler.h"
 #include "protocol.h"
 #include "util.h"

 using namespace std::chrono_literals;

 using android::base::SendFileDescriptors;
 using android::base::unique_fd;

 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 = (dump_type == kDebuggerdNativeBacktrace) ? 1 : 0;

   if (sigqueue(pid, signal, val) != 0) {
     PLOG(ERROR) << "libdebuggerd_client: failed to send signal to pid " << pid;
     return false;
   }
   return true;
 }

 template <typename Duration>
 static void populate_timeval(struct timeval* tv, const Duration& duration) {
   auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
   auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration - seconds);
   tv->tv_sec = static_cast<long>(seconds.count());
   tv->tv_usec = static_cast<long>(microseconds.count());
 }

 bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int timeout_ms,
                             unique_fd output_fd) {
   pid_t pid = tid;
   if (dump_type == kDebuggerdJavaBacktrace) {
     // Java dumps always get sent to the tgid, so we need to resolve our tid to a tgid.
     android::procinfo::ProcessInfo procinfo;
     std::string error;
     if (!android::procinfo::GetProcessInfo(tid, &procinfo, &error)) {
       LOG(ERROR) << "libdebugged_client: failed to get process info: " << error;
       return false;
     }
     pid = procinfo.pid;
   }

   LOG(INFO) << "libdebuggerd_client: started dumping process " << pid;
   unique_fd sockfd;
   const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
   auto time_left = [&end]() { return end - std::chrono::steady_clock::now(); };
   auto set_timeout = [timeout_ms, &time_left](int sockfd) {
     if (timeout_ms <= 0) {
       return sockfd;
     }

     auto remaining = time_left();
     if (remaining < decltype(remaining)::zero()) {
       LOG(ERROR) << "libdebuggerd_client: timeout expired";
       return -1;
     }

     struct timeval timeout;
     populate_timeval(&timeout, remaining);

     if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0) {
       PLOG(ERROR) << "libdebuggerd_client: failed to set receive timeout";
       return -1;
     }
     if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) != 0) {
       PLOG(ERROR) << "libdebuggerd_client: failed to set send timeout";
       return -1;
     }

     return sockfd;
   };

   sockfd.reset(socket(AF_LOCAL, SOCK_SEQPACKET, 0));
   if (sockfd == -1) {
     PLOG(ERROR) << "libdebugger_client: failed to create socket";
     return false;
   }

   if (socket_local_client_connect(set_timeout(sockfd.get()), kTombstonedInterceptSocketName,
                                   ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET) == -1) {
     PLOG(ERROR) << "libdebuggerd_client: failed to connect to tombstoned";
     return false;
   }

   InterceptRequest req = {.pid = pid, .dump_type = dump_type};
   if (!set_timeout(sockfd)) {
     PLOG(ERROR) << "libdebugger_client: failed to set timeout";
     return false;
   }

   // Create an intermediate pipe to pass to the other end.
   unique_fd pipe_read, pipe_write;
   if (!Pipe(&pipe_read, &pipe_write)) {
     PLOG(ERROR) << "libdebuggerd_client: failed to create pipe";
     return false;
   }

   std::string pipe_size_str;
   int pipe_buffer_size = 1024 * 1024;
   if (android::base::ReadFileToString("/proc/sys/fs/pipe-max-size", &pipe_size_str)) {
     pipe_size_str = android::base::Trim(pipe_size_str);

     if (!android::base::ParseInt(pipe_size_str.c_str(), &pipe_buffer_size, 0)) {
       LOG(FATAL) << "failed to parse pipe max size '" << pipe_size_str << "'";
     }
   }

   if (fcntl(pipe_read.get(), F_SETPIPE_SZ, pipe_buffer_size) != pipe_buffer_size) {
     PLOG(ERROR) << "failed to set pipe buffer size";
   }

   ssize_t rc = SendFileDescriptors(set_timeout(sockfd), &req, sizeof(req), pipe_write.get());
   pipe_write.reset();
   if (rc != sizeof(req)) {
     PLOG(ERROR) << "libdebuggerd_client: failed to send output fd to tombstoned";
     return false;
   }

   // Check to make sure we've successfully registered.
   InterceptResponse response;
   rc = TEMP_FAILURE_RETRY(recv(set_timeout(sockfd.get()), &response, sizeof(response), MSG_TRUNC));
   if (rc == 0) {
     LOG(ERROR) << "libdebuggerd_client: failed to read initial response from tombstoned: "
                << "timeout reached?";
     return false;
   } else if (rc == -1) {
     PLOG(ERROR) << "libdebuggerd_client: failed to read initial response from tombstoned";
     return false;
   } else if (rc != sizeof(response)) {
     LOG(ERROR) << "libdebuggerd_client: received packet of unexpected length from tombstoned while "
                   "reading initial response: expected "
                << sizeof(response) << ", received " << rc;
     return false;
   }

   if (response.status != InterceptStatus::kRegistered) {
     LOG(ERROR) << "libdebuggerd_client: unexpected registration response: "
                << static_cast<int>(response.status);
     return false;
   }

   if (!send_signal(tid, dump_type)) {
     return false;
   }

   rc = TEMP_FAILURE_RETRY(recv(set_timeout(sockfd.get()), &response, sizeof(response), MSG_TRUNC));
   if (rc == 0) {
     LOG(ERROR) << "libdebuggerd_client: failed to read status response from tombstoned: "
                   "timeout reached?";
     return false;
   } else if (rc == -1) {
     PLOG(ERROR) << "libdebuggerd_client: failed to read status response from tombstoned";
     return false;
   } else if (rc != sizeof(response)) {
     LOG(ERROR) << "libdebuggerd_client: received packet of unexpected length from tombstoned while "
                   "reading confirmation response: expected "
                << sizeof(response) << ", received " << rc;
     return false;
   }

   if (response.status != InterceptStatus::kStarted) {
     response.error_message[sizeof(response.error_message) - 1] = '\0';
     LOG(ERROR) << "libdebuggerd_client: tombstoned reported failure: " << response.error_message;
     return false;
   }

   // Forward output from the pipe to the output fd.
   while (true) {
     auto remaining_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_left()).count();
     if (timeout_ms <= 0) {
       remaining_ms = -1;
     } else if (remaining_ms < 0) {
       LOG(ERROR) << "libdebuggerd_client: timeout expired";
       return false;
     }

     struct pollfd pfd = {
         .fd = pipe_read.get(), .events = POLLIN, .revents = 0,
     };

     rc = poll(&pfd, 1, remaining_ms);
     if (rc == -1) {
       if (errno == EINTR) {
         continue;
       } else {
         PLOG(ERROR) << "libdebuggerd_client: error while polling";
         return false;
       }
     } else if (rc == 0) {
       LOG(ERROR) << "libdebuggerd_client: timeout expired";
       return false;
     }

     char buf[1024];
     rc = TEMP_FAILURE_RETRY(read(pipe_read.get(), buf, sizeof(buf)));
     if (rc == 0) {
       // Done.
       break;
     } else if (rc == -1) {
       PLOG(ERROR) << "libdebuggerd_client: error while reading";
       return false;
     }

     if (!android::base::WriteFully(output_fd.get(), buf, rc)) {
       PLOG(ERROR) << "libdebuggerd_client: error while writing";
       return false;
     }
   }

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

   return true;
 }

 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, 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, dump_type, timeout_ms, std::move(copy)) ? 0 : -1;
 }
	/*
	* Copyright 2016, 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 <debuggerd/client.h>

	#include <fcntl.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <sys/poll.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <chrono>

	#include <android-base/cmsg.h>
	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/parseint.h>
	#include <android-base/stringprintf.h>
	#include <android-base/strings.h>
	#include <android-base/unique_fd.h>
	#include <cutils/sockets.h>
	#include <procinfo/process.h>

	#include "debuggerd/handler.h"
	#include "protocol.h"
	#include "util.h"

	using namespace std::chrono_literals;

	using android::base::SendFileDescriptors;
	using android::base::unique_fd;

	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 = (dump_type == kDebuggerdNativeBacktrace) ? 1 : 0;

	if (sigqueue(pid, signal, val) != 0) {
	PLOG(ERROR) << "libdebuggerd_client: failed to send signal to pid " << pid;
	return false;
	}
	return true;
	}

	template <typename Duration>
	static void populate_timeval(struct timeval* tv, const Duration& duration) {
	auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
	auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration - seconds);
	tv->tv_sec = static_cast<long>(seconds.count());
	tv->tv_usec = static_cast<long>(microseconds.count());
	}

	bool debuggerd_trigger_dump(pid_t tid, DebuggerdDumpType dump_type, unsigned int timeout_ms,
	unique_fd output_fd) {
	pid_t pid = tid;
	if (dump_type == kDebuggerdJavaBacktrace) {
	// Java dumps always get sent to the tgid, so we need to resolve our tid to a tgid.
	android::procinfo::ProcessInfo procinfo;
	std::string error;
	if (!android::procinfo::GetProcessInfo(tid, &procinfo, &error)) {
	LOG(ERROR) << "libdebugged_client: failed to get process info: " << error;
	return false;
	}
	pid = procinfo.pid;
	}

	LOG(INFO) << "libdebuggerd_client: started dumping process " << pid;
	unique_fd sockfd;
	const auto end = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
	auto time_left = [&end]() { return end - std::chrono::steady_clock::now(); };
	auto set_timeout = [timeout_ms, &time_left](int sockfd) {
	if (timeout_ms <= 0) {
	return sockfd;
	}

	auto remaining = time_left();
	if (remaining < decltype(remaining)::zero()) {
	LOG(ERROR) << "libdebuggerd_client: timeout expired";
	return -1;
	}

	struct timeval timeout;
	populate_timeval(&timeout, remaining);

	if (setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) != 0) {
	PLOG(ERROR) << "libdebuggerd_client: failed to set receive timeout";
	return -1;
	}
	if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) != 0) {
	PLOG(ERROR) << "libdebuggerd_client: failed to set send timeout";
	return -1;
	}

	return sockfd;
	};

	sockfd.reset(socket(AF_LOCAL, SOCK_SEQPACKET, 0));
	if (sockfd == -1) {
	PLOG(ERROR) << "libdebugger_client: failed to create socket";
	return false;
	}

	if (socket_local_client_connect(set_timeout(sockfd.get()), kTombstonedInterceptSocketName,
	ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET) == -1) {
	PLOG(ERROR) << "libdebuggerd_client: failed to connect to tombstoned";
	return false;
	}

	InterceptRequest req = {.pid = pid, .dump_type = dump_type};
	if (!set_timeout(sockfd)) {
	PLOG(ERROR) << "libdebugger_client: failed to set timeout";
	return false;
	}

	// Create an intermediate pipe to pass to the other end.
	unique_fd pipe_read, pipe_write;
	if (!Pipe(&pipe_read, &pipe_write)) {
	PLOG(ERROR) << "libdebuggerd_client: failed to create pipe";
	return false;
	}

	std::string pipe_size_str;
	int pipe_buffer_size = 1024 * 1024;
	if (android::base::ReadFileToString("/proc/sys/fs/pipe-max-size", &pipe_size_str)) {
	pipe_size_str = android::base::Trim(pipe_size_str);

	if (!android::base::ParseInt(pipe_size_str.c_str(), &pipe_buffer_size, 0)) {
	LOG(FATAL) << "failed to parse pipe max size '" << pipe_size_str << "'";
	}
	}

	if (fcntl(pipe_read.get(), F_SETPIPE_SZ, pipe_buffer_size) != pipe_buffer_size) {
	PLOG(ERROR) << "failed to set pipe buffer size";
	}

	ssize_t rc = SendFileDescriptors(set_timeout(sockfd), &req, sizeof(req), pipe_write.get());
	pipe_write.reset();
	if (rc != sizeof(req)) {
	PLOG(ERROR) << "libdebuggerd_client: failed to send output fd to tombstoned";
	return false;
	}

	// Check to make sure we've successfully registered.
	InterceptResponse response;
	rc = TEMP_FAILURE_RETRY(recv(set_timeout(sockfd.get()), &response, sizeof(response), MSG_TRUNC));
	if (rc == 0) {
	LOG(ERROR) << "libdebuggerd_client: failed to read initial response from tombstoned: "
	<< "timeout reached?";
	return false;
	} else if (rc == -1) {
	PLOG(ERROR) << "libdebuggerd_client: failed to read initial response from tombstoned";
	return false;
	} else if (rc != sizeof(response)) {
	LOG(ERROR) << "libdebuggerd_client: received packet of unexpected length from tombstoned while "
	"reading initial response: expected "
	<< sizeof(response) << ", received " << rc;
	return false;
	}

	if (response.status != InterceptStatus::kRegistered) {
	LOG(ERROR) << "libdebuggerd_client: unexpected registration response: "
	<< static_cast<int>(response.status);
	return false;
	}

	if (!send_signal(tid, dump_type)) {
	return false;
	}

	rc = TEMP_FAILURE_RETRY(recv(set_timeout(sockfd.get()), &response, sizeof(response), MSG_TRUNC));
	if (rc == 0) {
	LOG(ERROR) << "libdebuggerd_client: failed to read status response from tombstoned: "
	"timeout reached?";
	return false;
	} else if (rc == -1) {
	PLOG(ERROR) << "libdebuggerd_client: failed to read status response from tombstoned";
	return false;
	} else if (rc != sizeof(response)) {
	LOG(ERROR) << "libdebuggerd_client: received packet of unexpected length from tombstoned while "
	"reading confirmation response: expected "
	<< sizeof(response) << ", received " << rc;
	return false;
	}

	if (response.status != InterceptStatus::kStarted) {
	response.error_message[sizeof(response.error_message) - 1] = '\0';
	LOG(ERROR) << "libdebuggerd_client: tombstoned reported failure: " << response.error_message;
	return false;
	}

	// Forward output from the pipe to the output fd.
	while (true) {
	auto remaining_ms = std::chrono::duration_cast<std::chrono::milliseconds>(time_left()).count();
	if (timeout_ms <= 0) {
	remaining_ms = -1;
	} else if (remaining_ms < 0) {
	LOG(ERROR) << "libdebuggerd_client: timeout expired";
	return false;
	}

	struct pollfd pfd = {
	.fd = pipe_read.get(), .events = POLLIN, .revents = 0,
	};

	rc = poll(&pfd, 1, remaining_ms);
	if (rc == -1) {
	if (errno == EINTR) {
	continue;
	} else {
	PLOG(ERROR) << "libdebuggerd_client: error while polling";
	return false;
	}
	} else if (rc == 0) {
	LOG(ERROR) << "libdebuggerd_client: timeout expired";
	return false;
	}

	char buf[1024];
	rc = TEMP_FAILURE_RETRY(read(pipe_read.get(), buf, sizeof(buf)));
	if (rc == 0) {
	// Done.
	break;
	} else if (rc == -1) {
	PLOG(ERROR) << "libdebuggerd_client: error while reading";
	return false;
	}

	if (!android::base::WriteFully(output_fd.get(), buf, rc)) {
	PLOG(ERROR) << "libdebuggerd_client: error while writing";
	return false;
	}
	}

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

	return true;
	}

	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, 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, dump_type, timeout_ms, std::move(copy)) ? 0 : -1;
	}