| /* |
| * 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; |
| } |