| // 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 "src/developer/debug/zxdb/client/thread_impl.h" |
| |
| #include <gtest/gtest.h> |
| |
| #include "src/developer/debug/shared/message_loop.h" |
| #include "src/developer/debug/zxdb/client/frame.h" |
| #include "src/developer/debug/zxdb/client/mock_frame.h" |
| #include "src/developer/debug/zxdb/client/remote_api_test.h" |
| #include "src/developer/debug/zxdb/client/session.h" |
| #include "src/developer/debug/zxdb/client/step_thread_controller.h" |
| #include "src/developer/debug/zxdb/client/test_thread_observer.h" |
| #include "src/developer/debug/zxdb/client/thread_controller.h" |
| #include "src/developer/debug/zxdb/common/err.h" |
| #include "src/developer/debug/zxdb/symbols/input_location.h" |
| |
| namespace zxdb { |
| |
| namespace { |
| |
| class ThreadImplTest : public RemoteAPITest {}; |
| |
| // This ThreadController always responds with "continue". |
| class ContinueThreadController : public ThreadController { |
| public: |
| // The parameter is a variable to set when the OnThreadStop() function is called. It must outlive |
| // this class. |
| explicit ContinueThreadController(bool* got_stop) : got_stop_(got_stop) {} |
| ~ContinueThreadController() override = default; |
| |
| // ThreadController implementation. |
| void InitWithThread(Thread* thread, fit::callback<void(const Err&)> cb) override { |
| SetThread(thread); |
| cb(Err()); |
| } |
| ContinueOp GetContinueOp() override { return ContinueOp::Continue(); } |
| StopOp OnThreadStop(debug_ipc::ExceptionType stop_type, |
| const std::vector<fxl::WeakPtr<Breakpoint>>& hit_breakpoints) override { |
| *got_stop_ = true; |
| return kContinue; |
| } |
| const char* GetName() const override { return "Continue"; } |
| |
| private: |
| bool* got_stop_; |
| }; |
| |
| // This ThreadController always reports "kUnexpected" for stops. |
| class UnexpectedThreadController : public ThreadController { |
| public: |
| explicit UnexpectedThreadController() = default; |
| ~UnexpectedThreadController() override = default; |
| |
| // ThreadController implementation. |
| void InitWithThread(Thread* thread, fit::callback<void(const Err&)> cb) override { |
| SetThread(thread); |
| cb(Err()); |
| } |
| ContinueOp GetContinueOp() override { return ContinueOp::Continue(); } |
| StopOp OnThreadStop(debug_ipc::ExceptionType stop_type, |
| const std::vector<fxl::WeakPtr<Breakpoint>>& hit_breakpoints) override { |
| return kUnexpected; |
| } |
| const char* GetName() const override { return "Unexpected"; } |
| }; |
| |
| // This ThreadController responds twice with kFuture and then once with kStop. |
| class FutureThreadController : public ThreadController { |
| public: |
| explicit FutureThreadController() = default; |
| ~FutureThreadController() override = default; |
| |
| // ThreadController implementation. |
| void InitWithThread(Thread* thread, fit::callback<void(const Err&)> cb) override { |
| SetThread(thread); |
| cb(Err()); |
| } |
| ContinueOp GetContinueOp() override { return ContinueOp::Continue(); } |
| StopOp OnThreadStop(debug_ipc::ExceptionType stop_type, |
| const std::vector<fxl::WeakPtr<Breakpoint>>& hit_breakpoints) override { |
| if (futures_remaining_ == 0) |
| return kStopDone; |
| |
| futures_remaining_--; |
| return kFuture; |
| } |
| const char* GetName() const override { return "Future"; } |
| |
| private: |
| int futures_remaining_ = 2; |
| }; |
| |
| } // namespace |
| |
| TEST_F(ThreadImplTest, Frames) { |
| // Make a process and thread for notifying about. |
| constexpr uint64_t kProcessKoid = 1234; |
| InjectProcess(kProcessKoid); |
| constexpr uint64_t kThreadKoid = 5678; |
| Thread* thread = InjectThread(kProcessKoid, kThreadKoid); |
| |
| // The thread should be in a running state with no frames. |
| EXPECT_TRUE(thread->GetStack().empty()); |
| EXPECT_FALSE(thread->GetStack().has_all_frames()); |
| |
| constexpr uint64_t kAddress1 = 0x12345678; |
| constexpr uint64_t kStack1 = 0x7890; |
| constexpr uint64_t kAddress2 = 0x34567890; |
| constexpr uint64_t kStack2 = 0x7800; |
| |
| // Notify of thread stop. |
| debug_ipc::NotifyException break_notification; |
| break_notification.type = debug_ipc::ExceptionType::kSoftwareBreakpoint; |
| break_notification.thread.id = {.process = kProcessKoid, .thread = kThreadKoid}; |
| break_notification.thread.state = debug_ipc::ThreadRecord::State::kBlocked; |
| break_notification.thread.frames.emplace_back(kAddress1, kStack1, kStack2); |
| InjectException(break_notification); |
| |
| // There should be one frame with the address of the stop. |
| EXPECT_FALSE(thread->GetStack().has_all_frames()); |
| const Stack& stack = thread->GetStack(); |
| ASSERT_EQ(1u, stack.size()); |
| EXPECT_EQ(kAddress1, stack[0]->GetAddress()); |
| EXPECT_EQ(kStack1, stack[0]->GetStackPointer()); |
| |
| // Construct what the full stack will be returned to the thread. The top element should match the |
| // one already there. |
| debug_ipc::ThreadStatusReply expected_reply; |
| expected_reply.record = break_notification.thread; // Copies existing frame. |
| expected_reply.record.stack_amount = debug_ipc::ThreadRecord::StackAmount::kFull; |
| expected_reply.record.frames.emplace_back(kAddress2, kStack2, 0); |
| mock_remote_api()->set_thread_status_reply(expected_reply); |
| |
| // Asynchronously request the frames. |
| thread->GetStack().SyncFrames([](const Err&) { debug::MessageLoop::Current()->QuitNow(); }); |
| loop().Run(); |
| |
| // The thread should have the new stack we provided. |
| EXPECT_TRUE(thread->GetStack().has_all_frames()); |
| ASSERT_EQ(2u, stack.size()); |
| EXPECT_EQ(kAddress1, stack[0]->GetAddress()); |
| EXPECT_EQ(kStack1, stack[0]->GetStackPointer()); |
| EXPECT_EQ(kAddress2, stack[1]->GetAddress()); |
| EXPECT_EQ(kStack2, stack[1]->GetStackPointer()); |
| |
| // Resuming the thread should clear the frames. |
| mock_remote_api()->set_resume_quits_loop(true); |
| thread->Continue(false); |
| EXPECT_EQ(0u, thread->GetStack().size()); |
| EXPECT_FALSE(thread->GetStack().has_all_frames()); |
| loop().Run(); |
| |
| // After resuming we don't actually know what state the thread is in so nothing should change. If |
| // we have better thread state notifications in the future, it would be nice if the thread |
| // reported itself as running and the stack was cleared at this point. |
| } |
| |
| // Tests that general exceptions still run thread controllers. If the exception is at an address |
| // where the thread controller says "stop", that thread controller should be notified so it can be |
| // deleted. It doesn't matter what caused the stop if the thread controller thinks its done. |
| // |
| // For this exception case, the thread should always stop, even if the controllers say "continue." |
| TEST_F(ThreadImplTest, ControllersWithGeneralException) { |
| constexpr uint64_t kProcessKoid = 1234; |
| InjectProcess(kProcessKoid); |
| constexpr uint64_t kThreadKoid = 5678; |
| Thread* thread = InjectThread(kProcessKoid, kThreadKoid); |
| |
| // Notify of thread stop. |
| constexpr uint64_t kAddress1 = 0x12345678; |
| constexpr uint64_t kStack1 = 0x7890; |
| debug_ipc::NotifyException notification; |
| notification.type = debug_ipc::ExceptionType::kSoftwareBreakpoint; |
| notification.thread.id = {.process = kProcessKoid, .thread = kThreadKoid}; |
| notification.thread.state = debug_ipc::ThreadRecord::State::kBlocked; |
| notification.thread.frames.emplace_back(kAddress1, kStack1); |
| InjectException(notification); |
| |
| // Set a controller that always says to continue. |
| bool got_stop = false; |
| thread->ContinueWith(std::make_unique<ContinueThreadController>(&got_stop), |
| [](const Err& err) {}); |
| EXPECT_FALSE(got_stop); // Should not have been called. |
| |
| // Start watching for thread events starting now. |
| TestThreadObserver thread_observer(thread); |
| |
| // Notify on thread stop again (this is the same address as above but it doesn't matter). |
| notification.type = debug_ipc::ExceptionType::kGeneral; |
| InjectException(notification); |
| |
| // The controller should have been notified and the thread should have issued a stop notification |
| // even though the controller said to continue. |
| EXPECT_TRUE(got_stop); |
| EXPECT_TRUE(thread_observer.got_stopped()); |
| } |
| |
| // Tests conditions where thread controllers report unexpected stop types. |
| TEST_F(ThreadImplTest, ControllersUnexpected) { |
| constexpr uint64_t kProcessKoid = 1234; |
| InjectProcess(kProcessKoid); |
| constexpr uint64_t kThreadKoid = 5678; |
| Thread* thread = InjectThread(kProcessKoid, kThreadKoid); |
| |
| TestThreadObserver thread_observer(thread); |
| |
| // Notify of thread stop. |
| constexpr uint64_t kAddress1 = 0x12345678; |
| constexpr uint64_t kStack1 = 0x7890; |
| debug_ipc::NotifyException notification; |
| notification.type = debug_ipc::ExceptionType::kSoftwareBreakpoint; |
| notification.thread.id = {.process = kProcessKoid, .thread = kThreadKoid}; |
| notification.thread.state = debug_ipc::ThreadRecord::State::kBlocked; |
| notification.thread.frames.emplace_back(kAddress1, kStack1); |
| InjectException(notification); |
| |
| // No controllers means the thread should report "stopped". |
| EXPECT_TRUE(thread_observer.got_stopped()); |
| thread_observer.set_got_stopped(false); |
| |
| // Add the controller that always reports unexpected. |
| thread->ContinueWith(std::make_unique<UnexpectedThreadController>(), [](const Err& err) {}); |
| |
| // Notify on thread stop again (this is the same address as above but it doesn't matter). |
| notification.type = debug_ipc::ExceptionType::kSingleStep; |
| InjectException(notification); |
| |
| // When all controllers report unexpected, the thread should stop. |
| EXPECT_TRUE(thread_observer.got_stopped()); |
| thread_observer.set_got_stopped(false); |
| |
| // Add a continue controller and throw the exception. There should be one controller voting |
| // "continue" and one voting "unexpected" which should continue the thread. |
| bool continue_got_stop = false; |
| thread->ContinueWith(std::make_unique<ContinueThreadController>(&continue_got_stop), |
| [](const Err& err) {}); |
| InjectException(notification); |
| EXPECT_FALSE(thread_observer.got_stopped()); |
| } |
| |
| // Sends an exception with no stack. Any thread controllers should get deleted. |
| TEST_F(ThreadImplTest, StopNoStack) { |
| constexpr uint64_t kProcessKoid = 1234; |
| InjectProcess(kProcessKoid); |
| constexpr uint64_t kThreadKoid = 5678; |
| Thread* thread = InjectThread(kProcessKoid, kThreadKoid); |
| |
| TestThreadObserver thread_observer(thread); |
| |
| // Normal thread stop with a location to begin stepping. Then step. |
| std::vector<std::unique_ptr<Frame>> frames; |
| frames.push_back(std::make_unique<MockFrame>( |
| &session(), thread, Location(Location::State::kAddress, 0x7890), 0x1234)); |
| InjectExceptionWithStack(kProcessKoid, kThreadKoid, debug_ipc::ExceptionType::kSoftwareBreakpoint, |
| std::move(frames), false); |
| thread->ContinueWith(std::make_unique<StepThreadController>(StepMode::kInstruction), |
| [](const Err& err) {}); |
| |
| ThreadImpl* thread_impl = static_cast<ThreadImpl*>(thread); |
| EXPECT_FALSE(thread_impl->controllers_.empty()); |
| |
| // Notify on thread stop with no stack. |
| thread_observer.set_got_stopped(false); |
| InjectExceptionWithStack(kProcessKoid, kThreadKoid, debug_ipc::ExceptionType::kSoftwareBreakpoint, |
| {}, false); |
| thread_observer.set_got_stopped(false); |
| |
| // The thread controllers should be gone. |
| EXPECT_TRUE(thread_impl->controllers_.empty()); |
| } |
| |
| TEST_F(ThreadImplTest, JumpTo) { |
| constexpr uint64_t kProcessKoid = 1234; |
| InjectProcess(kProcessKoid); |
| constexpr uint64_t kThreadKoid = 5678; |
| Thread* thread = InjectThread(kProcessKoid, kThreadKoid); |
| |
| // Notify of thread stop. |
| constexpr uint64_t kAddress1 = 0x12345678; |
| constexpr uint64_t kStack = 0x7890; |
| debug_ipc::NotifyException notification; |
| notification.type = debug_ipc::ExceptionType::kSoftwareBreakpoint; |
| notification.thread.id = {.process = kProcessKoid, .thread = kThreadKoid}; |
| notification.thread.state = debug_ipc::ThreadRecord::State::kBlocked; |
| notification.thread.frames.emplace_back(kAddress1, kStack); |
| InjectException(notification); |
| |
| // Canned response for thread status. |
| constexpr uint64_t kDestAddress = 0x7828374510a; |
| debug_ipc::ThreadStatusReply status; |
| status.record = notification.thread; // Copies existing frame. |
| status.record.stack_amount = debug_ipc::ThreadRecord::StackAmount::kFull; |
| status.record.frames[0].ip = kDestAddress; |
| mock_remote_api()->set_thread_status_reply(status); |
| |
| // Do jump. |
| bool called = false; |
| Err out_err; |
| thread->JumpTo(kDestAddress, [&called, &out_err](const Err& err) { |
| called = true; |
| out_err = err; |
| debug::MessageLoop::Current()->QuitNow(); |
| }); |
| EXPECT_FALSE(called); |
| |
| // The command should have sent a request to write to the IP. There should be a single register |
| // with a value of the new address. |
| const auto& written = mock_remote_api()->last_write_registers().registers; |
| ASSERT_EQ(1u, written.size()); |
| ASSERT_EQ(sizeof(uint64_t), written[0].data.size()); |
| EXPECT_EQ(0, memcmp(&kDestAddress, &written[0].data[0], sizeof(uint64_t))); |
| |
| // The callback should be asynchronously received. |
| loop().Run(); |
| EXPECT_TRUE(called); |
| EXPECT_FALSE(out_err.has_error()); |
| |
| // The thread should be in the new location. |
| EXPECT_EQ(kDestAddress, thread->GetStack()[0]->GetAddress()); |
| } |
| |
| TEST_F(ThreadImplTest, FutureThreadController) { |
| constexpr uint64_t kProcessKoid = 1234; |
| InjectProcess(kProcessKoid); |
| constexpr uint64_t kThreadKoid = 5678; |
| Thread* thread = InjectThread(kProcessKoid, kThreadKoid); |
| |
| TestThreadObserver thread_observer(thread); |
| |
| // Notify of thread stop. |
| constexpr uint64_t kAddress1 = 0x12345678; |
| constexpr uint64_t kStack1 = 0x7890; |
| debug_ipc::NotifyException notification; |
| notification.type = debug_ipc::ExceptionType::kSingleStep; |
| notification.thread.id = {.process = kProcessKoid, .thread = kThreadKoid}; |
| notification.thread.state = debug_ipc::ThreadRecord::State::kBlocked; |
| notification.thread.frames.emplace_back(kAddress1, kStack1); |
| InjectException(notification); |
| |
| thread->ContinueWith(std::make_unique<FutureThreadController>(), [](const Err& err) {}); |
| thread_observer.set_got_stopped(false); |
| |
| // Notify on thread stop (this is the same address as above but it doesn't matter). The thread |
| // controller should report "future" and not notify. |
| InjectException(notification); |
| EXPECT_FALSE(thread_observer.got_stopped()); |
| |
| // Declare that future stop as complete. This will return another future. |
| thread->ResumeFromAsyncThreadController(std::nullopt); |
| EXPECT_FALSE(thread_observer.got_stopped()); |
| |
| // The third time the controller should report stop which should notify. |
| thread->ResumeFromAsyncThreadController(std::nullopt); |
| EXPECT_TRUE(thread_observer.got_stopped()); |
| } |
| |
| } // namespace zxdb |