| // Copyright 2023 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 "src/developer/debug/debug_agent/linux_thread_handle.h" | |
| #include <map> | |
| #include "src/developer/debug/debug_agent/linux_suspend_handle.h" | |
| #include "src/developer/debug/debug_agent/linux_utils.h" | |
| #include "src/developer/debug/shared/logging/logging.h" | |
| namespace debug_agent { | |
| LinuxThreadHandle::LinuxThreadHandle(fxl::RefPtr<LinuxTask> task) : task_(std::move(task)) {} | |
| std::string LinuxThreadHandle::GetName() const { return linux::GetStatus(task_->pid())["Name"]; } | |
| ThreadHandle::State LinuxThreadHandle::GetState() const { | |
| auto state = linux::ThreadStateFromLinuxState(linux::GetStatus(task_->pid())["State"]); | |
| if (!state) | |
| return State(debug_ipc::ThreadRecord::State::kDead); | |
| return *state; | |
| } | |
| std::unique_ptr<SuspendHandle> LinuxThreadHandle::Suspend() { | |
| DEBUG_LOG(Thread) << "Suspending thread " << task_->pid(); | |
| return std::make_unique<LinuxSuspendHandle>(task_); | |
| } | |
| bool LinuxThreadHandle::WaitForSuspension(TickTimePoint deadline) const { | |
| // Linux suspensions are synchronous so we never need to wait for one. | |
| return true; | |
| } | |
| debug_ipc::ThreadRecord LinuxThreadHandle::GetThreadRecord(zx_koid_t process_koid) const { | |
| DEBUG_LOG(Thread) << "LinuxThreadHandle::GetThreadRecord"; | |
| auto map = linux::GetStatus(task_->pid()); | |
| debug_ipc::ThreadRecord record; | |
| record.id = {.process = process_koid, .thread = static_cast<uint64_t>(task_->pid())}; | |
| record.name = map["Name"]; | |
| if (auto state = linux::ThreadStateFromLinuxState(map["State"])) { | |
| record.state = state->state; | |
| record.blocked_reason = state->blocked_reason; | |
| } else { | |
| record.state = debug_ipc::ThreadRecord::State::kDead; | |
| } | |
| return record; | |
| } | |
| std::optional<GeneralRegisters> LinuxThreadHandle::GetGeneralRegisters() const { | |
| if (auto result = linux::ReadGeneralRegisters(task_->pid())) { | |
| DEBUG_LOG(Thread) << "General registers IP = " << std::hex << "0x" << result->rip; | |
| return GeneralRegisters(*result); | |
| } | |
| return std::nullopt; | |
| } | |
| void LinuxThreadHandle::SetGeneralRegisters(const GeneralRegisters& regs) { | |
| linux::WriteGeneralRegisters(task_->pid(), regs.GetNativeRegisters()); | |
| } | |
| std::optional<DebugRegisters> LinuxThreadHandle::GetDebugRegisters() const { | |
| // TODO(brettw) implement this. | |
| return std::nullopt; | |
| } | |
| bool LinuxThreadHandle::SetDebugRegisters(const DebugRegisters& regs) { | |
| // TODO(brettw) implement this. | |
| return false; | |
| } | |
| void LinuxThreadHandle::SetSingleStep(bool single_step) { | |
| DEBUG_LOG(Thread) << "LinuxThreadHandle::SetSingleStep " << single_step; | |
| task_->set_single_step(single_step); | |
| } | |
| std::vector<debug::RegisterValue> LinuxThreadHandle::ReadRegisters( | |
| const std::vector<debug::RegisterCategory>& cats_to_get) const { | |
| // TODO(brettw) implement this. | |
| return {}; | |
| } | |
| std::vector<debug::RegisterValue> LinuxThreadHandle::WriteRegisters( | |
| const std::vector<debug::RegisterValue>& regs) { | |
| // TODO(brettw) implement this. | |
| return {}; | |
| } | |
| bool LinuxThreadHandle::InstallHWBreakpoint(uint64_t address) { | |
| // TODO(brettw) implement this. | |
| return false; | |
| } | |
| bool LinuxThreadHandle::UninstallHWBreakpoint(uint64_t address) { | |
| // TODO(brettw) implement this. | |
| return false; | |
| } | |
| std::optional<WatchpointInfo> LinuxThreadHandle::InstallWatchpoint( | |
| debug_ipc::BreakpointType type, const debug::AddressRange& range) { | |
| // TODO(brettw) implement this. | |
| return std::nullopt; | |
| } | |
| bool LinuxThreadHandle::UninstallWatchpoint(const debug::AddressRange& range) { | |
| // TODO(brettw) implement this. | |
| return false; | |
| } | |
| } // namespace debug_agent |