| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "garnet/lib/debug_ipc/helper/message_loop_async.h" |
| |
| #include <stdio.h> |
| |
| #include <lib/fdio/io.h> |
| #include <lib/zx/handle.h> |
| #include <lib/zx/job.h> |
| #include <lib/zx/process.h> |
| #include <zircon/syscalls/exception.h> |
| |
| #include "garnet/lib/debug_ipc/debug/block_timer.h" |
| #include "garnet/lib/debug_ipc/helper/event_handlers.h" |
| #include "garnet/lib/debug_ipc/helper/fd_watcher.h" |
| #include "garnet/lib/debug_ipc/helper/socket_watcher.h" |
| #include "garnet/lib/debug_ipc/helper/zircon_exception_watcher.h" |
| #include "garnet/lib/debug_ipc/helper/zx_status.h" |
| #include "garnet/public/lib/fxl/compiler_specific.h" |
| #include "garnet/public/lib/fxl/logging.h" |
| |
| namespace debug_ipc { |
| |
| namespace { |
| |
| thread_local MessageLoopAsync* current_message_loop_async = nullptr; |
| |
| } // namespace |
| |
| // Exception ------------------------------------------------------------ |
| |
| struct MessageLoopAsync::Exception { |
| zx_koid_t thread_koid = 0; |
| // Not-owning. Must outlive. |
| async_exception_t* exception_token = nullptr; |
| }; |
| |
| // MessageLoopAsync ----------------------------------------------------------- |
| |
| MessageLoopAsync::MessageLoopAsync() : loop_(&kAsyncLoopConfigAttachToThread) {} |
| |
| MessageLoopAsync::~MessageLoopAsync() { |
| FXL_DCHECK(Current() != this); // Cleanup should have been called. |
| } |
| |
| void MessageLoopAsync::Init() { |
| MessageLoop::Init(); |
| |
| FXL_DCHECK(!current_message_loop_async); |
| current_message_loop_async = this; |
| MessageLoopTarget::current_message_loop_type = |
| MessageLoopTarget::LoopType::kAsync; |
| |
| zx::event::create(0, &task_event_); |
| |
| WatchInfo info; |
| info.type = WatchType::kTask; |
| AddSignalHandler(kTaskSignalKey, task_event_.get(), kTaskSignal, &info); |
| watches_[kTaskSignalKey] = info; |
| } |
| |
| void MessageLoopAsync::Cleanup() { |
| // We need to remove the signal/exception handlers before the message loop |
| // goes away. |
| signal_handlers_.clear(); |
| exception_handlers_.clear(); |
| |
| FXL_DCHECK(current_message_loop_async == this); |
| current_message_loop_async = nullptr; |
| MessageLoopTarget::current_message_loop_type = |
| MessageLoopTarget::LoopType::kLast; |
| |
| MessageLoop::Cleanup(); |
| } |
| |
| // static |
| MessageLoopAsync* MessageLoopAsync::Current() { |
| return current_message_loop_async; |
| } |
| |
| const MessageLoopAsync::WatchInfo* MessageLoopAsync::FindWatchInfo( |
| int id) const { |
| auto it = watches_.find(id); |
| if (it == watches_.end()) |
| return nullptr; |
| return &it->second; |
| } |
| |
| void MessageLoopAsync::AddSignalHandler(int id, zx_handle_t object, |
| zx_signals_t signals, |
| WatchInfo* associated_info) { |
| SignalHandler handler(id, object, signals); |
| |
| // The handler should not be there already. |
| FXL_DCHECK(signal_handlers_.find(handler.handle()) == signal_handlers_.end()); |
| |
| associated_info->signal_handler_key = handler.handle(); |
| signal_handlers_[handler.handle()] = std::move(handler); |
| } |
| |
| void MessageLoopAsync::AddExceptionHandler(int id, zx_handle_t object, |
| uint32_t options, |
| WatchInfo* associated_info) { |
| ExceptionHandler handler(id, object, options); |
| |
| // The handler should not be there already. |
| FXL_DCHECK(exception_handlers_.find(handler.handle()) == |
| exception_handlers_.end()); |
| |
| associated_info->exception_handler_key = handler.handle(); |
| exception_handlers_[handler.handle()] = std::move(handler); |
| } |
| |
| MessageLoop::WatchHandle MessageLoopAsync::WatchFD(WatchMode mode, int fd, |
| FDWatcher* watcher) { |
| WatchInfo info; |
| info.type = WatchType::kFdio; |
| info.fd_watcher = watcher; |
| info.fd = fd; |
| info.fdio = fdio_unsafe_fd_to_io(fd); |
| if (!info.fdio) |
| return WatchHandle(); |
| |
| uint32_t events = 0; |
| switch (mode) { |
| case WatchMode::kRead: |
| events = POLLIN; |
| break; |
| case WatchMode::kWrite: |
| events = POLLOUT; |
| break; |
| case WatchMode::kReadWrite: |
| events = POLLIN | POLLOUT; |
| break; |
| } |
| |
| zx_signals_t signals = ZX_SIGNAL_NONE; |
| fdio_unsafe_wait_begin(info.fdio, events, &info.fd_handle, &signals); |
| if (info.fd_handle == ZX_HANDLE_INVALID) |
| return WatchHandle(); |
| |
| int watch_id; |
| { |
| std::lock_guard<std::mutex> guard(mutex_); |
| |
| watch_id = next_watch_id_; |
| next_watch_id_++; |
| } |
| |
| AddSignalHandler(watch_id, info.fd_handle, signals, &info); |
| watches_[watch_id] = info; |
| return WatchHandle(this, watch_id); |
| } |
| |
| MessageLoop::WatchHandle MessageLoopAsync::WatchSocket( |
| WatchMode mode, zx_handle_t socket_handle, SocketWatcher* watcher) { |
| WatchInfo info; |
| info.type = WatchType::kSocket; |
| info.socket_watcher = watcher; |
| info.socket_handle = socket_handle; |
| |
| int watch_id; |
| { |
| std::lock_guard<std::mutex> guard(mutex_); |
| |
| watch_id = next_watch_id_; |
| next_watch_id_++; |
| } |
| |
| zx_signals_t signals = 0; |
| if (mode == WatchMode::kRead || mode == WatchMode::kReadWrite) |
| signals |= ZX_SOCKET_READABLE; |
| |
| if (mode == WatchMode::kWrite || mode == WatchMode::kReadWrite) |
| signals |= ZX_SOCKET_WRITABLE; |
| |
| AddSignalHandler(watch_id, socket_handle, ZX_SOCKET_WRITABLE, &info); |
| watches_[watch_id] = info; |
| return WatchHandle(this, watch_id); |
| } |
| |
| MessageLoop::WatchHandle MessageLoopAsync::WatchProcessExceptions( |
| zx_handle_t process_handle, zx_koid_t process_koid, |
| ZirconExceptionWatcher* watcher) { |
| WatchInfo info; |
| info.type = WatchType::kProcessExceptions; |
| info.exception_watcher = watcher; |
| info.task_koid = process_koid; |
| info.task_handle = process_handle; |
| |
| int watch_id; |
| { |
| std::lock_guard<std::mutex> guard(mutex_); |
| |
| watch_id = next_watch_id_; |
| next_watch_id_++; |
| } |
| |
| // Watch all exceptions for the process. |
| AddExceptionHandler(watch_id, process_handle, ZX_EXCEPTION_PORT_DEBUGGER, |
| &info); |
| |
| // Watch for the process terminated signal. |
| AddSignalHandler(watch_id, process_handle, ZX_PROCESS_TERMINATED, &info); |
| |
| watches_[watch_id] = info; |
| return WatchHandle(this, watch_id); |
| } |
| |
| MessageLoop::WatchHandle MessageLoopAsync::WatchJobExceptions( |
| zx_handle_t job_handle, zx_koid_t job_koid, |
| ZirconExceptionWatcher* watcher) { |
| WatchInfo info; |
| info.type = WatchType::kJobExceptions; |
| info.exception_watcher = watcher; |
| info.task_koid = job_koid; |
| info.task_handle = job_handle; |
| |
| int watch_id; |
| { |
| std::lock_guard<std::mutex> guard(mutex_); |
| |
| watch_id = next_watch_id_; |
| next_watch_id_++; |
| } |
| |
| // Create and track the exception handle. |
| AddExceptionHandler(watch_id, job_handle, ZX_EXCEPTION_PORT_DEBUGGER, &info); |
| watches_[watch_id] = info; |
| return WatchHandle(this, watch_id); |
| } |
| |
| zx_status_t MessageLoopAsync::ResumeFromException(zx_koid_t thread_koid, |
| zx::thread& thread, |
| uint32_t options) { |
| auto it = thread_exception_map_.find(thread_koid); |
| FXL_DCHECK(it != thread_exception_map_.end()); |
| zx_status_t res = async_resume_from_exception(async_get_default_dispatcher(), |
| it->second.exception_token, |
| thread.get(), options); |
| thread_exception_map_.erase(thread_koid); |
| return res; |
| } |
| |
| bool MessageLoopAsync::CheckAndProcessPendingTasks() { |
| std::lock_guard<std::mutex> guard(mutex_); |
| // Do a C++ task. |
| if (ProcessPendingTask()) { |
| SetHasTasks(); // Enqueue another task signal. |
| return true; |
| } |
| return false; |
| } |
| |
| void MessageLoopAsync::HandleException(const ExceptionHandler& handler, |
| zx_port_packet_t packet) { |
| WatchInfo* watch_info = nullptr; |
| { |
| // Some event being watched. |
| std::lock_guard<std::mutex> guard(mutex_); |
| auto found = watches_.find(packet.key); |
| if (found == watches_.end()) { |
| // It is possible to get an exception that doesn't have a watch handle. |
| // A case is a race between detaching from a process and getting an |
| // exception on that process. |
| // |
| // The normal process looks like this: |
| // |
| // 1. In order to correctly detach, the debug agent has to resume threads |
| // from their exceptions. Otherwise that exception will be treated as |
| // unhandled when the agent detaches and will bubble up. |
| // 2. The agent detaches from the exception port. This means that the |
| // watch handle is no longer listening. |
| // |
| // It is possible between (1) and (2) to get an exception, which will be |
| // queued in the exception port of the thread. Now, the agent won't read |
| // from the port until *after* it has detached from the exception port. |
| // This means that this new exception is not handled and will be bubbled |
| // up, which is correct as the debug agent stated that it has nothing more |
| // to do with the process. |
| // |
| // Now the problem is that zircon does not clean stale packets from a |
| // queue, meaning that the next time the message loop waits on the port, |
| // it will find a stale packet. In this context a stale packet means one |
| // that does not have a watch handle, as it was deleted in (1). Hence we |
| // get into this case and we simply log it for posperity. |
| // |
| // TODO(ZX-2623): zircon is going to clean up stale packets from ports |
| // in the future. When that is done, this case should not |
| // happen and we should go back into asserting it. |
| FXL_LOG(WARNING) << "Got stale port packet. This is most probably due to " |
| "a race between detaching from a process and an " |
| "exception ocurring."; |
| return; |
| } |
| watch_info = &found->second; |
| } |
| |
| // Dispatch the watch callback outside of the lock. This depends on the |
| // stability of the WatchInfo pointer in the map (std::map is stable across |
| // updates) and the watch not getting unregistered from another thread |
| // asynchronously (which the API requires and is enforced by a DCHECK in |
| // the StopWatching impl). |
| switch (watch_info->type) { |
| case WatchType::kProcessExceptions: |
| OnProcessException(handler, *watch_info, packet); |
| break; |
| case WatchType::kJobExceptions: |
| OnJobException(handler, *watch_info, packet); |
| break; |
| case WatchType::kTask: |
| case WatchType::kFdio: |
| case WatchType::kSocket: |
| FXL_NOTREACHED(); |
| } |
| } |
| |
| void MessageLoopAsync::RunUntilTimeout(zx::duration timeout) { |
| // Init should have been called. |
| FXL_DCHECK(Current() == this); |
| zx_status_t status; |
| status = loop_.ResetQuit(); |
| FXL_DCHECK(status != ZX_ERR_BAD_STATE); |
| status = loop_.Run(zx::deadline_after(timeout)); |
| FXL_DCHECK(status == ZX_OK || status == ZX_ERR_TIMED_OUT) |
| << "Expected ZX_OK || ZX_ERR_TIMED_OUT, got " << ZxStatusToString(status); |
| } |
| |
| // Previously, the approach was to first look for C++ tasks and when handled |
| // look for WatchHandle work and finally wait for an event. This worked because |
| // handle events didn't post C++ tasks. |
| // |
| // But some tests do post tasks on handle events. Because C++ tasks are signaled |
| // by explicitly signaling an zx::event, without manually checking, the C++ |
| // tasks will never be checked and we would get blocked until a watch handled |
| // is triggered. |
| // |
| // In order to handle the events properly, we need to check for C++ tasks before |
| // and *after* handling watch handle events. This way we always process C++ |
| // tasks before handle events and will get signaled if one of them posted a new |
| // task. |
| void MessageLoopAsync::RunImpl() { |
| FXL_LOG(INFO) << __FUNCTION__; |
| // Init should have been called. |
| FXL_DCHECK(Current() == this); |
| zx_status_t status; |
| |
| status = loop_.ResetQuit(); |
| FXL_DCHECK(status != ZX_ERR_BAD_STATE); |
| status = loop_.Run(); |
| FXL_DCHECK(status == ZX_OK || status == ZX_ERR_CANCELED) |
| << "Expected ZX_OK || ZX_ERR_CANCELED, got " << ZxStatusToString(status); |
| } |
| |
| void MessageLoopAsync::QuitNow() { |
| MessageLoop::QuitNow(); |
| loop_.Quit(); |
| } |
| |
| void MessageLoopAsync::StopWatching(int id) { |
| // The dispatch code for watch callbacks requires this be called on the |
| // same thread as the message loop is. |
| FXL_DCHECK(Current() == this); |
| |
| std::lock_guard<std::mutex> guard(mutex_); |
| |
| auto found = watches_.find(id); |
| FXL_DCHECK(found != watches_.end()); |
| |
| WatchInfo& info = found->second; |
| |
| switch (info.type) { |
| case WatchType::kProcessExceptions: { |
| RemoveExceptionHandler(info.exception_handler_key); |
| RemoveSignalHandler(info.signal_handler_key); |
| break; |
| } |
| case WatchType::kJobExceptions: { |
| RemoveExceptionHandler(info.exception_handler_key); |
| break; |
| } |
| case WatchType::kTask: |
| case WatchType::kFdio: |
| case WatchType::kSocket: |
| RemoveSignalHandler(info.signal_handler_key); |
| break; |
| } |
| watches_.erase(found); |
| } |
| |
| void MessageLoopAsync::SetHasTasks() { task_event_.signal(0, kTaskSignal); } |
| |
| void MessageLoopAsync::OnFdioSignal(int watch_id, const WatchInfo& info, |
| zx_signals_t observed) { |
| TIME_BLOCK(); |
| |
| uint32_t events = 0; |
| fdio_unsafe_wait_end(info.fdio, observed, &events); |
| |
| if ((events & POLLERR) || (events & POLLHUP) || (events & POLLNVAL) || |
| (events & POLLRDHUP)) { |
| info.fd_watcher->OnFDError(info.fd); |
| |
| // Don't dispatch any other notifications when there's an error. Zircon |
| // seems to set readable and writable on error even if there's nothing |
| // there. |
| return; |
| } |
| |
| // Since notifications can cause the watcher to be removed, this flag tracks |
| // if anything has been issued and therefore we should re-check the watcher |
| // registration before dereferencing anything. |
| bool sent_notification = false; |
| |
| if (events & POLLIN) { |
| info.fd_watcher->OnFDReadable(info.fd); |
| sent_notification = true; |
| } |
| |
| if (events & POLLOUT) { |
| if (sent_notification) { |
| std::lock_guard<std::mutex> guard(mutex_); |
| if (watches_.find(watch_id) == watches_.end()) |
| return; |
| } |
| info.fd_watcher->OnFDWritable(info.fd); |
| sent_notification = true; |
| } |
| } |
| |
| void MessageLoopAsync::RemoveSignalHandler(const async_wait_t* key) { |
| FXL_DCHECK(key); |
| size_t erase_count = signal_handlers_.erase(key); |
| FXL_DCHECK(erase_count == 1u); |
| } |
| |
| void MessageLoopAsync::RemoveExceptionHandler(const async_exception_t* key) { |
| FXL_DCHECK(key); |
| size_t erase_count = exception_handlers_.erase(key); |
| FXL_DCHECK(erase_count == 1u); |
| } |
| |
| void MessageLoopAsync::AddException(const ExceptionHandler& handler, |
| zx_koid_t thread_koid) { |
| FXL_DCHECK(thread_exception_map_.find(thread_koid) == |
| thread_exception_map_.end()); |
| |
| Exception exception; |
| exception.thread_koid = thread_koid; |
| exception.exception_token = const_cast<async_exception_t*>(handler.handle()); |
| thread_exception_map_[thread_koid] = std::move(exception); |
| } |
| |
| void MessageLoopAsync::OnProcessException(const ExceptionHandler& handler, |
| const WatchInfo& info, |
| const zx_port_packet_t& packet) { |
| TIME_BLOCK(); |
| |
| if (ZX_PKT_IS_EXCEPTION(packet.type)) { |
| // All debug exceptions. |
| switch (packet.type) { |
| case ZX_EXCP_THREAD_STARTING: |
| AddException(handler, packet.exception.tid); |
| info.exception_watcher->OnThreadStarting(info.task_koid, |
| packet.exception.tid); |
| break; |
| case ZX_EXCP_THREAD_EXITING: |
| AddException(handler, packet.exception.tid); |
| info.exception_watcher->OnThreadExiting(info.task_koid, |
| packet.exception.tid); |
| break; |
| case ZX_EXCP_GENERAL: |
| case ZX_EXCP_FATAL_PAGE_FAULT: |
| case ZX_EXCP_UNDEFINED_INSTRUCTION: |
| case ZX_EXCP_SW_BREAKPOINT: |
| case ZX_EXCP_HW_BREAKPOINT: |
| case ZX_EXCP_UNALIGNED_ACCESS: |
| case ZX_EXCP_POLICY_ERROR: |
| AddException(handler, packet.exception.tid); |
| info.exception_watcher->OnException(info.task_koid, |
| packet.exception.tid, packet.type); |
| break; |
| default: |
| FXL_NOTREACHED(); |
| } |
| } else { |
| FXL_NOTREACHED(); |
| } |
| } |
| |
| void MessageLoopAsync::OnProcessTerminated(const WatchInfo& info, |
| zx_signals_t observed) { |
| FXL_DCHECK(observed & ZX_PROCESS_TERMINATED); |
| info.exception_watcher->OnProcessTerminated(info.task_koid); |
| } |
| |
| void MessageLoopAsync::OnJobException(const ExceptionHandler& handler, |
| const WatchInfo& info, |
| const zx_port_packet_t& packet) { |
| TIME_BLOCK(); |
| |
| if (ZX_PKT_IS_EXCEPTION(packet.type)) { |
| // All debug exceptions. |
| switch (packet.type) { |
| case ZX_EXCP_PROCESS_STARTING: |
| AddException(handler, packet.exception.tid); |
| info.exception_watcher->OnProcessStarting( |
| info.task_koid, packet.exception.pid, packet.exception.tid); |
| return; |
| default: |
| break; |
| } |
| } |
| FXL_NOTREACHED(); |
| } |
| |
| void MessageLoopAsync::OnSocketSignal(int watch_id, const WatchInfo& info, |
| zx_signals_t observed) { |
| TIME_BLOCK(); |
| |
| FXL_LOG(INFO) << __FUNCTION__; |
| // Dispatch readable signal. |
| if (observed & ZX_SOCKET_READABLE) |
| info.socket_watcher->OnSocketReadable(info.socket_handle); |
| |
| // When signaling both readable and writable, make sure the readable handler |
| // didn't remove the watch. |
| if ((observed & ZX_SOCKET_READABLE) && (observed & ZX_SOCKET_WRITABLE)) { |
| std::lock_guard<std::mutex> guard(mutex_); |
| if (watches_.find(watch_id) == watches_.end()) |
| return; |
| } |
| |
| // Dispatch writable signal. |
| if (observed & ZX_SOCKET_WRITABLE) |
| info.socket_watcher->OnSocketWritable(info.socket_handle); |
| } |
| |
| } // namespace debug_ipc |