blob: 61a639543166befc8bea4ba9b9249b8780b7b681 [file]
// 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/process_impl.h"
#include <gtest/gtest.h>
#include "src/developer/debug/zxdb/client/frame.h"
#include "src/developer/debug/zxdb/client/memory_dump.h"
#include "src/developer/debug/zxdb/client/mock_remote_api.h"
#include "src/developer/debug/zxdb/client/process_observer.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/target_impl.h"
#include "src/developer/debug/zxdb/client/thread.h"
#include "src/developer/debug/zxdb/client/thread_observer.h"
#include "src/developer/debug/zxdb/symbols/elf_symbol.h"
#include "src/developer/debug/zxdb/symbols/function.h"
#include "src/developer/debug/zxdb/symbols/mock_module_symbols.h"
namespace zxdb {
namespace {
class ProcessSink : public MockRemoteAPI {
public:
ProcessSink() = default;
~ProcessSink() = default;
const debug_ipc::ResumeRequest& resume_request() const { return resume_request_; }
int resume_count() const { return resume_count_; }
int modules_count() const { return modules_count_; }
void set_modules_reply(debug_ipc::ModulesReply reply) { modules_reply_ = std::move(reply); }
void Resume(const debug_ipc::ResumeRequest& request,
fit::callback<void(const Err&, debug_ipc::ResumeReply)> cb) override {
resume_count_++;
resume_request_ = request;
debug::MessageLoop::Current()->PostTask(
FROM_HERE, [cb = std::move(cb)]() mutable { cb(Err(), debug_ipc::ResumeReply()); });
}
void Modules(const debug_ipc::ModulesRequest& request,
fit::callback<void(const Err&, debug_ipc::ModulesReply)> cb) override {
modules_count_++;
debug::MessageLoop::Current()->PostTask(
FROM_HERE,
[cb = std::move(cb), reply = modules_reply_]() mutable { cb(Err(), std::move(reply)); });
}
// No-op.
void Threads(const debug_ipc::ThreadsRequest& request,
fit::callback<void(const Err&, debug_ipc::ThreadsReply)> cb) override {
thread_request_made_ = true;
}
bool thread_request_made() const { return thread_request_made_; }
private:
debug_ipc::ResumeRequest resume_request_;
int resume_count_ = 0;
debug_ipc::ModulesReply modules_reply_;
int modules_count_ = 0;
bool thread_request_made_ = false;
};
class ProcessImplTest : public RemoteAPITest {
public:
ProcessImplTest() = default;
~ProcessImplTest() override = default;
ProcessSink* sink() { return sink_; }
private:
std::unique_ptr<RemoteAPI> GetRemoteAPIImpl() override {
auto sink = std::make_unique<ProcessSink>();
sink_ = sink.get();
return sink;
}
private:
ProcessSink* sink_; // Owned by the session.
};
// Tests that the correct threads are resumed after the modules are loaded.
TEST_F(ProcessImplTest, OnModules) {
constexpr uint64_t kProcessKoid = 1234;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
EXPECT_FALSE(sink()->thread_request_made());
debug_ipc::NotifyModules notify;
notify.process_koid = kProcessKoid;
notify.modules.resize(1);
notify.modules[0].name = "comctl32.dll";
notify.modules[0].base = 0x7685348234;
session().DispatchNotifyModules(notify);
EXPECT_TRUE(sink()->thread_request_made());
// Should have resumed both of those threads.
ASSERT_EQ(1, sink()->resume_count());
const debug_ipc::ResumeRequest& resume = sink()->resume_request();
EXPECT_EQ(debug_ipc::ResumeRequest::How::kResolveAndContinue, resume.how);
EXPECT_EQ(1U, resume.ids.size());
EXPECT_EQ(debug_ipc::ProcessThreadId{.process = kProcessKoid}, resume.ids[0]);
}
TEST_F(ProcessImplTest, GetTLSHelpers) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kThreadKoid = 5678;
constexpr char kBuildId[] = "abcd";
constexpr uint64_t kModuleBase = 0x1000;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
Thread* thread = InjectThread(kProcessKoid, kThreadKoid);
ASSERT_TRUE(thread);
SymbolContext symbol_context(kModuleBase);
auto module_symbols = fxl::MakeRefCounted<MockModuleSymbols>("libc.so");
session().system().GetSymbols()->InjectModuleForTesting(kBuildId, module_symbols.get());
std::vector<debug_ipc::Module> modules;
debug_ipc::Module module;
module.name = "libc";
module.base = kModuleBase;
module.build_id = kBuildId;
modules.push_back(module);
TargetImpl* target = session().system().GetTargetImpls()[0];
target->process()->OnModules(modules);
constexpr uint64_t kThrdTAddr = 0x1000;
constexpr uint64_t kLinkMapTlsModIdAddr = 0x2000;
constexpr uint64_t kTlsBaseAddr = 0x3000;
constexpr uint64_t kSymSize = 4;
ElfSymbolRecord thrd_t_record(ElfSymbolType::kNormal, kThrdTAddr, kSymSize, "zxdb.thrd_t");
ElfSymbolRecord link_map_tls_modid_record(ElfSymbolType::kNormal, kLinkMapTlsModIdAddr, kSymSize,
"zxdb.link_map_tls_modid");
ElfSymbolRecord tlsbase_record(ElfSymbolType::kNormal, kTlsBaseAddr, kSymSize, "zxdb.tlsbase");
auto thrd_t_sym = fxl::MakeRefCounted<ElfSymbol>(module_symbols->GetWeakPtr(), thrd_t_record);
auto link_map_tls_modid_sym =
fxl::MakeRefCounted<ElfSymbol>(module_symbols->GetWeakPtr(), link_map_tls_modid_record);
auto tlsbase_sym = fxl::MakeRefCounted<ElfSymbol>(module_symbols->GetWeakPtr(), tlsbase_record);
module_symbols->AddSymbolLocations(
Identifier(IdentifierComponent(SpecialIdentifier::kElf, "zxdb.thrd_t")),
{Location(kThrdTAddr + kModuleBase, FileLine(), 0, symbol_context, thrd_t_sym)});
module_symbols->AddSymbolLocations(
Identifier(IdentifierComponent(SpecialIdentifier::kElf, "zxdb.link_map_tls_modid")),
{Location(kLinkMapTlsModIdAddr + kModuleBase, FileLine(), 0, symbol_context,
link_map_tls_modid_sym)});
module_symbols->AddSymbolLocations(
Identifier(IdentifierComponent(SpecialIdentifier::kElf, "zxdb.tlsbase")),
{Location(kTlsBaseAddr + kModuleBase, FileLine(), 0, symbol_context, tlsbase_sym)});
sink()->AddMemory(kThrdTAddr + kModuleBase, {0x1, 0x2, 0x3, 0x4});
sink()->AddMemory(kLinkMapTlsModIdAddr + kModuleBase, {0x5, 0x6, 0x7, 0x8});
sink()->AddMemory(kTlsBaseAddr + kModuleBase, {0x9, 0xa, 0xb, 0xc});
bool called = false;
bool called_2 = false;
Process::TLSHelpers helpers;
Process::TLSHelpers helpers_2;
Err err;
Err err_2;
process->GetTLSHelpers([&called, &helpers, &err](ErrOr<const Process::TLSHelpers*> got) {
called = true;
if (got.has_error()) {
err = got.err();
} else {
helpers = *got.value();
}
});
process->GetTLSHelpers([&called_2, &helpers_2, &err_2](ErrOr<const Process::TLSHelpers*> got) {
called_2 = true;
if (got.has_error()) {
err_2 = got.err();
} else {
helpers_2 = *got.value();
}
});
EXPECT_FALSE(called);
EXPECT_FALSE(called_2);
loop().RunUntilNoTasks();
EXPECT_TRUE(called);
EXPECT_TRUE(called_2);
ASSERT_FALSE(err.has_error()) << err.msg();
EXPECT_FALSE(err_2.has_error());
ASSERT_EQ(helpers.thrd_t.size(), kSymSize);
ASSERT_EQ(helpers.link_map_tls_modid.size(), kSymSize);
ASSERT_EQ(helpers.tlsbase.size(), kSymSize);
EXPECT_EQ(0x1, helpers.thrd_t[0]);
EXPECT_EQ(0x2, helpers.thrd_t[1]);
EXPECT_EQ(0x3, helpers.thrd_t[2]);
EXPECT_EQ(0x4, helpers.thrd_t[3]);
EXPECT_EQ(0x5, helpers.link_map_tls_modid[0]);
EXPECT_EQ(0x6, helpers.link_map_tls_modid[1]);
EXPECT_EQ(0x7, helpers.link_map_tls_modid[2]);
EXPECT_EQ(0x8, helpers.link_map_tls_modid[3]);
EXPECT_EQ(0x9, helpers.tlsbase[0]);
EXPECT_EQ(0xa, helpers.tlsbase[1]);
EXPECT_EQ(0xb, helpers.tlsbase[2]);
EXPECT_EQ(0xc, helpers.tlsbase[3]);
EXPECT_EQ(0x1, helpers_2.thrd_t[0]);
EXPECT_EQ(0x2, helpers_2.thrd_t[1]);
EXPECT_EQ(0x3, helpers_2.thrd_t[2]);
EXPECT_EQ(0x4, helpers_2.thrd_t[3]);
EXPECT_EQ(0x5, helpers_2.link_map_tls_modid[0]);
EXPECT_EQ(0x6, helpers_2.link_map_tls_modid[1]);
EXPECT_EQ(0x7, helpers_2.link_map_tls_modid[2]);
EXPECT_EQ(0x8, helpers_2.link_map_tls_modid[3]);
EXPECT_EQ(0x9, helpers_2.tlsbase[0]);
EXPECT_EQ(0xa, helpers_2.tlsbase[1]);
EXPECT_EQ(0xb, helpers_2.tlsbase[2]);
EXPECT_EQ(0xc, helpers_2.tlsbase[3]);
called = false;
process->GetTLSHelpers([&called, &helpers, &err](ErrOr<const Process::TLSHelpers*> got) {
called = true;
if (got.has_error()) {
err = got.err();
} else {
helpers = *got.value();
}
});
EXPECT_TRUE(called);
ASSERT_FALSE(err.has_error()) << err.msg();
ASSERT_EQ(helpers.thrd_t.size(), kSymSize);
ASSERT_EQ(helpers.link_map_tls_modid.size(), kSymSize);
ASSERT_EQ(helpers.tlsbase.size(), kSymSize);
EXPECT_EQ(0x1, helpers.thrd_t[0]);
EXPECT_EQ(0x2, helpers.thrd_t[1]);
EXPECT_EQ(0x3, helpers.thrd_t[2]);
EXPECT_EQ(0x4, helpers.thrd_t[3]);
EXPECT_EQ(0x5, helpers.link_map_tls_modid[0]);
EXPECT_EQ(0x6, helpers.link_map_tls_modid[1]);
EXPECT_EQ(0x7, helpers.link_map_tls_modid[2]);
EXPECT_EQ(0x8, helpers.link_map_tls_modid[3]);
EXPECT_EQ(0x9, helpers.tlsbase[0]);
EXPECT_EQ(0xa, helpers.tlsbase[1]);
EXPECT_EQ(0xb, helpers.tlsbase[2]);
EXPECT_EQ(0xc, helpers.tlsbase[3]);
}
TEST_F(ProcessImplTest, ReadMemoryAutomation) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kThreadKoid = 5678;
constexpr uint64_t kBlockAddress = 0xdeadbeef;
constexpr uint64_t kBlockSize = 8;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
ProcessImpl* process_impl = session().system().ProcessImplFromKoid(process->GetKoid());
ASSERT_TRUE(process_impl);
// This creates the memory block to mimic getting a response from an automated breakpoint.
debug_ipc::MemoryBlock mem_block = {.address = kBlockAddress, .valid = true, .size = kBlockSize};
mem_block.data = {0, 1, 2, 3, 4, 5, 6, 7};
debug_ipc::MemoryBlock invalid_mem_block = {
.address = kBlockAddress + 32, .valid = false, .size = kBlockSize};
invalid_mem_block.data = {10, 11, 12, 13, 14, 15, 16, 17};
std::vector<debug_ipc::MemoryBlock> mem_block_vect = {mem_block, invalid_mem_block};
process_impl->SetMemoryBlocks(kThreadKoid, mem_block_vect);
// This puts some memory on the mock remote device such that if the read misses the memory block
// it'll read from this array.
sink()->AddMemory(kBlockAddress - 4, {100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115});
// Attempt to read the memory block. The read request must be for a subset of one of the blocks
// returned for it to hit the memory block, otherwise it falls through to the remote device.
process_impl->ReadMemory(
kBlockAddress, kBlockSize, [](const zxdb::Err& err, zxdb::MemoryDump dump) {
ASSERT_EQ(dump.blocks()[0].data, std::vector<uint8_t>({0, 1, 2, 3, 4, 5, 6, 7}));
ASSERT_TRUE(dump.blocks()[0].valid);
});
// Read with a lower address, which should fall through to the remote device.
process_impl->ReadMemory(kBlockAddress - 2, kBlockSize,
[](const zxdb::Err& err, zxdb::MemoryDump dump) {
ASSERT_EQ(dump.blocks()[0].data, std::vector<uint8_t>({
102,
103,
104,
105,
106,
107,
108,
109,
}));
ASSERT_TRUE(dump.blocks()[0].valid);
});
// Read with a too large size, which should also fall through to the remote device.
process_impl->ReadMemory(kBlockAddress, kBlockSize + 2,
[](const zxdb::Err& err, zxdb::MemoryDump dump) {
ASSERT_EQ(dump.blocks()[0].data, std::vector<uint8_t>({
104,
105,
106,
107,
108,
109,
110,
111,
112,
113,
}));
ASSERT_TRUE(dump.blocks()[0].valid);
});
// Read a subset of the block, which should not fall through.
process_impl->ReadMemory(kBlockAddress + 2, kBlockSize - 4,
[](const zxdb::Err& err, zxdb::MemoryDump dump) {
ASSERT_EQ(dump.blocks()[0].data, std::vector<uint8_t>({
2,
3,
4,
5,
}));
ASSERT_TRUE(dump.blocks()[0].valid);
});
// Read a subset from the invalid block, which should not fall through, and also should not return
// any data in the blocks.
process_impl->ReadMemory(kBlockAddress + 32, kBlockSize - 2,
[](const zxdb::Err& err, zxdb::MemoryDump dump) {
ASSERT_EQ(dump.blocks()[0].data.size(), 0ul);
ASSERT_FALSE(dump.blocks()[0].valid);
});
loop().RunUntilNoTasks();
}
TEST_F(ProcessImplTest, ObserverOrder) {
// An observer that requires the process to be created before any threads are created.
class EnforceOrderObserver : public ProcessObserver, public ThreadObserver {
public:
void DidCreateProcess(Process* process, uint64_t timestamp) override {
process_created = true;
last_process = process;
}
void DidCreateThread(Thread* thread) override {
// This is the core requirement: Process should be created before threads.
EXPECT_TRUE(process_created);
EXPECT_EQ(last_process, thread->GetProcess());
thread_created = true;
last_thread_koid = thread->GetKoid();
}
bool process_created = false;
bool thread_created = false;
Process* last_process = nullptr;
uint64_t last_thread_koid = 0;
};
EnforceOrderObserver observer;
session().process_observers().AddObserver(&observer);
session().thread_observers().AddObserver(&observer);
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kThreadKoid = 5678;
debug_ipc::ProcessRecord record;
record.process_koid = kProcessKoid;
record.process_name = "process";
record.threads.resize(1);
record.threads[0].id = {.process = kProcessKoid, .thread = kThreadKoid};
TargetImpl* target = session().system().GetTargetImpls()[0];
auto process = ProcessImpl::FromPreviousProcess(target, record);
EXPECT_TRUE(observer.process_created);
EXPECT_TRUE(observer.thread_created);
EXPECT_EQ(process.get(), observer.last_process);
EXPECT_EQ(kThreadKoid, observer.last_thread_koid);
session().process_observers().RemoveObserver(&observer);
session().thread_observers().RemoveObserver(&observer);
}
TEST_F(ProcessImplTest, AllThreadsStopped) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kThreadKoid1 = 5678;
constexpr uint64_t kThreadKoid2 = 5679;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
// Process with no threads should return false.
EXPECT_FALSE(process->AllThreadsStopped());
Thread* thread1 = InjectThread(kProcessKoid, kThreadKoid1);
ASSERT_TRUE(thread1);
// Single running thread should return false.
EXPECT_FALSE(process->AllThreadsStopped());
// Ignoring the only thread in the process leaves no stopped threads.
EXPECT_FALSE(process->AllThreadsStopped(thread1));
// Stop thread1 on an exception (supports frames).
debug_ipc::NotifyException stop1;
stop1.type = debug_ipc::ExceptionType::kSingleStep;
stop1.thread.id = {.process = kProcessKoid, .thread = kThreadKoid1};
stop1.thread.state = debug_ipc::ThreadRecord::State::kBlocked;
stop1.thread.blocked_reason = debug_ipc::ThreadRecord::BlockedReason::kException;
InjectExceptionWithStack(stop1, {}, true);
EXPECT_TRUE(process->AllThreadsStopped());
EXPECT_FALSE(process->AllThreadsStopped(thread1));
// Add a second running thread.
Thread* thread2 = InjectThread(kProcessKoid, kThreadKoid2);
ASSERT_TRUE(thread2);
// Not all threads are stopped since thread2 is running.
EXPECT_FALSE(process->AllThreadsStopped());
// Ignoring running thread2 means all remaining threads (thread1) are stopped.
EXPECT_TRUE(process->AllThreadsStopped(thread2));
// Ignoring stopped thread1 leaves running thread2, so returns false.
EXPECT_FALSE(process->AllThreadsStopped(thread1));
// Put thread2 into a blocked state that does NOT support frames (e.g., sleeping).
debug_ipc::NotifyException sleep2;
sleep2.type = debug_ipc::ExceptionType::kNone;
sleep2.thread.id = {.process = kProcessKoid, .thread = kThreadKoid2};
sleep2.thread.state = debug_ipc::ThreadRecord::State::kBlocked;
sleep2.thread.blocked_reason = debug_ipc::ThreadRecord::BlockedReason::kSleeping;
InjectExceptionWithStack(sleep2, {}, true);
EXPECT_FALSE(process->AllThreadsStopped());
EXPECT_TRUE(process->AllThreadsStopped(thread2));
// Stop thread2 in a state that supports frames.
debug_ipc::NotifyException stop2;
stop2.type = debug_ipc::ExceptionType::kSingleStep;
stop2.thread.id = {.process = kProcessKoid, .thread = kThreadKoid2};
stop2.thread.state = debug_ipc::ThreadRecord::State::kBlocked;
stop2.thread.blocked_reason = debug_ipc::ThreadRecord::BlockedReason::kException;
InjectExceptionWithStack(stop2, {}, true);
EXPECT_TRUE(process->AllThreadsStopped());
EXPECT_TRUE(process->AllThreadsStopped(thread1));
EXPECT_TRUE(process->AllThreadsStopped(thread2));
}
TEST_F(ProcessImplTest, PauseLoadsModulesWhenEmpty) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kThreadKoid = 5678;
constexpr char kBuildId[] = "abcd";
constexpr uint64_t kModuleBase = 0x1000;
constexpr uint64_t kFrameIp = 0x1020;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
ASSERT_TRUE(process->GetThreads().empty());
auto module_symbols = fxl::MakeRefCounted<MockModuleSymbols>("test_module.so", kBuildId, true);
auto fn = fxl::MakeRefCounted<Function>(DwarfTag::kSubprogram);
fn->set_assigned_name("DoLoop");
module_symbols->AddSymbolLocations(
kFrameIp, {Location(kFrameIp, FileLine("loop.cc", 10), 0, SymbolContext(kModuleBase), fn)});
session().system().GetSymbols()->InjectModuleForTesting(kBuildId, module_symbols.get());
ASSERT_TRUE(process->GetSymbols()->GetStatus().empty());
EXPECT_EQ(0, sink()->modules_count());
debug_ipc::ModulesReply modules_reply;
modules_reply.modules.resize(1);
modules_reply.modules[0].name = "test_module.so";
modules_reply.modules[0].base = kModuleBase;
modules_reply.modules[0].build_id = kBuildId;
sink()->set_modules_reply(modules_reply);
debug_ipc::PauseReply pause_reply;
pause_reply.threads.resize(1);
pause_reply.threads[0].id = {.process = kProcessKoid, .thread = kThreadKoid};
pause_reply.threads[0].state = debug_ipc::ThreadRecord::State::kSuspended;
pause_reply.threads[0].stack_amount = debug_ipc::ThreadRecord::StackAmount::kMinimal;
pause_reply.threads[0].frames.emplace_back(kFrameIp, 0x2000);
sink()->set_pause_reply(pause_reply);
bool paused = false;
size_t module_count_on_pause = 0;
bool top_frame_symbolized_on_pause = false;
process->Pause([&paused, &module_count_on_pause, &top_frame_symbolized_on_pause, process]() {
paused = true;
module_count_on_pause = process->GetSymbols()->GetStatus().size();
if (Thread* thread = process->GetThreadFromKoid(kThreadKoid);
thread && !thread->GetStack().empty()) {
top_frame_symbolized_on_pause = thread->GetStack()[0]->GetLocation().is_symbolized();
}
});
EXPECT_FALSE(paused);
loop().RunUntilNoTasks();
EXPECT_TRUE(paused);
EXPECT_EQ(1u, module_count_on_pause);
EXPECT_TRUE(top_frame_symbolized_on_pause);
EXPECT_EQ(1, sink()->modules_count());
Thread* thread = process->GetThreadFromKoid(kThreadKoid);
ASSERT_TRUE(thread);
EXPECT_EQ(debug_ipc::ThreadRecord::State::kSuspended, thread->GetState());
ASSERT_FALSE(thread->GetStack().empty());
EXPECT_EQ("loop.cc", thread->GetStack()[0]->GetLocation().file_line().file());
EXPECT_EQ(10, thread->GetStack()[0]->GetLocation().file_line().line());
auto status = process->GetSymbols()->GetStatus();
ASSERT_EQ(1u, status.size());
EXPECT_EQ("test_module.so", status[0].name);
EXPECT_EQ(kModuleBase, status[0].base);
EXPECT_EQ(kBuildId, status[0].build_id);
// A subsequent Pause when modules are already loaded should not issue a duplicate Modules RPC.
bool paused_again = false;
process->Pause([&paused_again]() { paused_again = true; });
loop().RunUntilNoTasks();
EXPECT_TRUE(paused_again);
EXPECT_EQ(1, sink()->modules_count());
}
TEST_F(ProcessImplTest, ReadBytesEmptyCacheReturnsError) {
constexpr uint64_t kProcessKoid = 1234;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
ProcessImpl* process_impl = session().system().ProcessImplFromKoid(process->GetKoid());
ASSERT_TRUE(process_impl);
uint64_t value = 0xdeadbeefULL;
unwinder::Error err = process_impl->ReadBytes(0x1000, sizeof(value), &value);
EXPECT_TRUE(err.has_err());
EXPECT_EQ(0xdeadbeefULL, value);
}
TEST_F(ProcessImplTest, FetchMemoryRangesSkipsCachedMultiFrameUnwind) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kStackBase = 0x100000;
constexpr uint32_t kInitialPrefetchSize = 8192;
constexpr size_t kNumFrames = 15;
constexpr size_t kRegsPerFrame = 4;
constexpr uint64_t kFrameStride = 64;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
ProcessImpl* process_impl = session().system().ProcessImplFromKoid(process->GetKoid());
ASSERT_TRUE(process_impl);
// Populate an 8 KiB stack buffer with distinct 64-bit register values for 15 frames.
std::vector<uint8_t> stack_data(kInitialPrefetchSize, 0);
for (size_t frame = 0; frame < kNumFrames; ++frame) {
for (size_t reg = 0; reg < kRegsPerFrame; ++reg) {
uint64_t expected_val = 0xabcd0000ULL + (frame << 8U) + reg;
size_t offset = (frame * kFrameStride) + (reg * sizeof(uint64_t));
memcpy(&stack_data[offset], &expected_val, sizeof(expected_val));
}
}
sink()->AddMemory(kStackBase, std::move(stack_data));
sink()->ResetReadMemoryMetrics();
// Perform the initial 8 KiB stack prefetch that AsyncUnwindLoop::Unwind issues at frame 0.
bool prefetch_done = false;
process_impl->FetchMemoryRanges({{kStackBase, kInitialPrefetchSize}},
[&prefetch_done]() { prefetch_done = true; });
loop().RunUntilNoTasks();
EXPECT_TRUE(prefetch_done);
EXPECT_EQ(1UL, sink()->read_memory_count());
EXPECT_EQ(kInitialPrefetchSize, sink()->read_memory_total_bytes());
// Simulate 15 frames of CfiParser::AsyncStep fetching 4 saved 8-byte registers per frame.
// Because all 60 register slots fall inside the cached 8 KiB prefetch, zero additional
// ReadMemory RPCs should be sent over the wire.
for (size_t frame = 0; frame < kNumFrames; ++frame) {
uint64_t frame_base = kStackBase + (frame * kFrameStride);
std::vector<std::pair<uint64_t, uint32_t>> frame_ranges;
frame_ranges.reserve(kRegsPerFrame);
for (size_t reg = 0; reg < kRegsPerFrame; ++reg) {
frame_ranges.emplace_back(frame_base + (reg * sizeof(uint64_t)), sizeof(uint64_t));
}
bool step_done = false;
process_impl->FetchMemoryRanges(std::move(frame_ranges), [&step_done]() { step_done = true; });
loop().RunUntilNoTasks();
EXPECT_TRUE(step_done);
for (size_t reg = 0; reg < kRegsPerFrame; ++reg) {
uint64_t actual_val = 0;
unwinder::Error err = process_impl->ReadBytes(frame_base + (reg * sizeof(uint64_t)),
sizeof(actual_val), &actual_val);
ASSERT_TRUE(err.ok()) << err.msg();
EXPECT_EQ(0xabcd0000ULL + (frame << 8U) + reg, actual_val);
}
}
EXPECT_EQ(1UL, sink()->read_memory_count());
EXPECT_EQ(kInitialPrefetchSize, sink()->read_memory_total_bytes());
}
TEST_F(ProcessImplTest, FetchMemoryRangesCoalescesStarnixRestrictedRegisters) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kRestrictedStateAddr = 0x500000;
constexpr size_t kNumRegisters = 33; // x0..x30, sp, pc in ARM64 restricted_return_loop
constexpr uint32_t kRegSize = 8;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
ProcessImpl* process_impl = session().system().ProcessImplFromKoid(process->GetKoid());
ASSERT_TRUE(process_impl);
std::vector<uint8_t> state_bytes(kNumRegisters * kRegSize, 0);
for (size_t i = 0; i < kNumRegisters; ++i) {
uint64_t val = 0x90000000ULL + i;
memcpy(&state_bytes[i * kRegSize], &val, sizeof(val));
}
sink()->AddMemory(kRestrictedStateAddr, std::move(state_bytes));
sink()->ResetReadMemoryMetrics();
// Construct 33 already-sorted adjacent 8-byte ranges, matching CfiParser::AsyncStep iterating
// over std::map<RegisterID, RegisterLocation> for restricted_return_loop.
std::vector<std::pair<uint64_t, uint32_t>> ranges;
ranges.reserve(kNumRegisters);
for (size_t i = 0; i < kNumRegisters; ++i) {
ranges.emplace_back(kRestrictedStateAddr + (i * kRegSize), kRegSize);
}
bool done = false;
process_impl->FetchMemoryRanges(std::move(ranges), [&done]() { done = true; });
loop().RunUntilNoTasks();
EXPECT_TRUE(done);
// All 33 adjacent 8-byte ranges must coalesce into a single 264-byte ReadMemory request.
ASSERT_EQ(1UL, sink()->read_memory_count());
EXPECT_EQ(kRestrictedStateAddr, sink()->read_memory_requests()[0].address);
EXPECT_EQ(kNumRegisters * kRegSize, sink()->read_memory_requests()[0].size);
EXPECT_EQ(kNumRegisters * kRegSize, sink()->read_memory_total_bytes());
for (size_t i = 0; i < kNumRegisters; ++i) {
uint64_t val = 0;
ASSERT_TRUE(
process_impl->ReadBytes(kRestrictedStateAddr + (i * kRegSize), kRegSize, &val).ok());
EXPECT_EQ(0x90000000ULL + i, val);
}
}
TEST_F(ProcessImplTest, FetchMemoryRangesCoalescesOverlappingAndInvalidatesOnContinue) {
constexpr uint64_t kProcessKoid = 1234;
constexpr uint64_t kThreadKoid = 5678;
Process* process = InjectProcess(kProcessKoid);
ASSERT_TRUE(process);
Thread* thread = InjectThread(kProcessKoid, kThreadKoid);
ASSERT_TRUE(thread);
ProcessImpl* process_impl = session().system().ProcessImplFromKoid(process->GetKoid());
ASSERT_TRUE(process_impl);
sink()->AddMemory(0x2000, std::vector<uint8_t>(32, 0x11));
sink()->AddMemory(0x4000, std::vector<uint8_t>(16, 0x22));
sink()->ResetReadMemoryMetrics();
// Pass unsorted, overlapping, adjacent, zero-length, and overflowing ranges across two disjoint
// regions.
std::vector<std::pair<uint64_t, uint32_t>> ranges = {
{0x4008, 8}, {0x2008, 16}, {0x2000, 0}, {std::numeric_limits<uint64_t>::max() - 3, 8},
{0x4000, 8}, {0x2000, 12}, {0x2018, 8},
};
bool done = false;
process_impl->FetchMemoryRanges(std::move(ranges), [&done]() { done = true; });
loop().RunUntilNoTasks();
EXPECT_TRUE(done);
ASSERT_EQ(2UL, sink()->read_memory_count());
EXPECT_EQ(0x2000UL, sink()->read_memory_requests()[0].address);
EXPECT_EQ(32U, sink()->read_memory_requests()[0].size);
EXPECT_EQ(0x4000UL, sink()->read_memory_requests()[1].address);
EXPECT_EQ(16U, sink()->read_memory_requests()[1].size);
uint64_t val = 0;
EXPECT_TRUE(process_impl->ReadBytes(0x2010, sizeof(val), &val).ok());
EXPECT_EQ(0x1111111111111111ULL, val);
// Continuing the process must invalidate the unwinder memory cache.
process->Continue(false);
loop().RunUntilNoTasks();
EXPECT_TRUE(process_impl->ReadBytes(0x2010, sizeof(val), &val).has_err());
}
} // namespace
} // namespace zxdb