| // 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/debug_agent/zircon_system_interface.h" | |
| #include <memory> | |
| #include <string_view> | |
| #include <gtest/gtest.h> | |
| #include "fidl/fuchsia.component/cpp/fidl.h" | |
| #include "src/developer/debug/debug_agent/component_manager.h" | |
| #include "src/developer/debug/debug_agent/system_interface.h" | |
| #include "src/developer/debug/debug_agent/testing/runtime_dir_helper.h" | |
| #include "src/developer/debug/debug_agent/zircon_process_handle.h" | |
| #include "src/developer/debug/debug_agent/zircon_utils.h" | |
| #include "src/developer/debug/ipc/filter_utils.h" | |
| #include "src/developer/debug/ipc/records.h" | |
| #include "src/developer/debug/shared/event_pair_watcher.h" | |
| #include "src/developer/debug/shared/message_loop.h" | |
| #include "src/developer/debug/shared/message_loop_fuchsia.h" | |
| #include "src/developer/debug/shared/test_with_loop.h" | |
| namespace debug_agent { | |
| namespace { | |
| // Recursively walks the process tree and returns true if there is a process | |
| // matching the given koid. Fills the process_name if such process can be found. | |
| // Fills the component_info if the process belongs to some component. | |
| bool FindProcess(const debug_ipc::ProcessTreeRecord& record, zx_koid_t koid_to_find, | |
| std::string* process_name, std::vector<debug_ipc::ComponentInfo>* component_info) { | |
| if (record.koid == koid_to_find) { | |
| *process_name = record.name; | |
| return true; | |
| } | |
| for (const auto& child : record.children) { | |
| if (FindProcess(child, koid_to_find, process_name, component_info)) { | |
| if (!record.components.empty()) { | |
| component_info->insert(component_info->end(), record.components.begin(), | |
| record.components.end()); | |
| } | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| class ZirconSystemInterfaceTest : public debug::TestWithLoop, public debug::EventPairWatcher { | |
| public: | |
| debug::MessageLoopFuchsia& loop() { | |
| return reinterpret_cast<debug::MessageLoopFuchsia&>(debug::TestWithLoop::loop()); | |
| } | |
| // EventPairWatcher implementation. | |
| void OnPeerClosed(zx_handle_t) override { loop().QuitNow(); } | |
| }; | |
| TEST_F(ZirconSystemInterfaceTest, DISABLED_GetProcessTree) { | |
| ZirconSystemInterface system_interface; | |
| system_interface.zircon_component_manager().SetReadyCallback([&]() { loop().QuitNow(); }); | |
| loop().Run(); | |
| debug_ipc::ProcessTreeRecord root = system_interface.GetProcessTree(); | |
| // The root node should be a job with some children. | |
| EXPECT_EQ(debug_ipc::TaskType::kJob, root.type); | |
| EXPECT_FALSE(root.children.empty()); | |
| // Query ourself. | |
| auto self = zx::process::self(); | |
| zx_koid_t self_koid = zircon::KoidForObject(*self); | |
| ASSERT_NE(ZX_KOID_INVALID, self_koid); | |
| // Our koid should be somewhere in the tree. | |
| std::string process_name; | |
| std::vector<debug_ipc::ComponentInfo> all_component_info; | |
| EXPECT_TRUE(FindProcess(root, self_koid, &process_name, &all_component_info)); | |
| // The process_name and component info should match | |
| EXPECT_EQ(zircon::NameForObject(*self), process_name); | |
| ASSERT_FALSE(all_component_info.empty()); | |
| ASSERT_EQ(all_component_info.size(), 1ull); | |
| const auto& component_info = all_component_info[0]; | |
| EXPECT_EQ(".", component_info.moniker); | |
| // The url will include a hash that cannot be compared. | |
| ASSERT_FALSE(component_info.url.empty()); | |
| std::string_view prefix = "fuchsia-pkg://fuchsia.com/debug_agent_unit_tests"; | |
| std::string_view suffix = "#meta/debug_agent_unit_tests.cm"; | |
| ASSERT_GE(component_info.url.size(), prefix.size() + suffix.size()); | |
| EXPECT_EQ(prefix, component_info.url.substr(0, prefix.size())); | |
| EXPECT_EQ(suffix, component_info.url.substr(component_info.url.size() - suffix.size())); | |
| } | |
| TEST_F(ZirconSystemInterfaceTest, DISABLED_FindComponentInfo) { | |
| ZirconSystemInterface system_interface; | |
| system_interface.zircon_component_manager().SetReadyCallback([&]() { loop().QuitNow(); }); | |
| loop().Run(); | |
| zx::process handle; | |
| zx::process::self()->duplicate(ZX_RIGHT_SAME_RIGHTS, &handle); | |
| ZirconProcessHandle self(std::move(handle)); | |
| auto components = system_interface.GetComponentManager().FindComponentInfo(self); | |
| ASSERT_EQ(components.size(), 1ull); | |
| auto component_info = components[0]; | |
| EXPECT_EQ(".", component_info.moniker); | |
| // The url will include a hash that cannot be compared. | |
| ASSERT_FALSE(component_info.url.empty()); | |
| std::string_view prefix = "fuchsia-pkg://fuchsia.com/debug_agent_unit_tests"; | |
| std::string_view suffix = "#meta/debug_agent_unit_tests.cm"; | |
| ASSERT_GE(component_info.url.size(), prefix.size() + suffix.size()); | |
| EXPECT_EQ(prefix, component_info.url.substr(0, prefix.size())); | |
| EXPECT_EQ(suffix, component_info.url.substr(component_info.url.size() - suffix.size())); | |
| } | |
| TEST_F(ZirconSystemInterfaceTest, ComponentEvents) { | |
| ZirconSystemInterface system_interface; | |
| // Need a concrete instance to call |OnComponentEvent| directly. | |
| ZirconComponentManager* zircon_component_manager = | |
| reinterpret_cast<ZirconComponentManager*>(&system_interface.GetComponentManager()); | |
| constexpr char kElfMoniker[] = "some/moniker"; | |
| constexpr char kElfUrl[] = "fuchsia-pkg://fuchsia.com/package1#meta/component.cm"; | |
| constexpr char kNonElfMoniker[] = "some/non_elf/moniker"; | |
| constexpr char kNonElfUrl[] = "fuchsia-pkg://fuchsia.com/package2#meta/non_elf.cm"; | |
| constexpr zx_koid_t kExpectedKoid = 23; | |
| testing::RuntimeDirHelper helper; | |
| helper.AddJobIdFile(kExpectedKoid); | |
| helper.Start(loop().dispatcher()); | |
| // Inject an ELF component. | |
| fuchsia_component::EventHeader header; | |
| header.component_url(kElfUrl); | |
| header.moniker(kElfMoniker); | |
| header.event_type(fuchsia_component::EventType::kDebugStarted); | |
| fuchsia_component::Event event; | |
| event.header() = std::move(header); | |
| zx::eventpair left, right; | |
| ASSERT_EQ(zx_eventpair_create(0, left.reset_and_get_address(), right.reset_and_get_address()), | |
| ZX_OK); | |
| fuchsia_component::DebugStartedPayload payload; | |
| payload.runtime_dir() = helper.GetScopedDirectoryHandle(kExpectedKoid); | |
| payload.break_on_start() = std::move(right); | |
| event.payload() = fuchsia_component::EventPayload::WithDebugStarted(std::move(payload)); | |
| // Inject the event. | |
| zircon_component_manager->OnComponentEvent(std::move(event)); | |
| debug::MessageLoop::WatchHandle handle; | |
| loop().WatchEventPair(left.get(), this, &handle); | |
| loop().Run(); | |
| const auto& info = system_interface.GetComponentManager().FindComponentInfo(kExpectedKoid); | |
| EXPECT_EQ(info.size(), 1u); | |
| EXPECT_EQ(info[0].moniker, kElfMoniker); | |
| EXPECT_EQ(info[0].url, kElfUrl); | |
| fuchsia_component::EventHeader stopped_header; | |
| stopped_header.component_url(kElfUrl); | |
| stopped_header.moniker(kElfMoniker); | |
| stopped_header.event_type(fuchsia_component::EventType::kStopped); | |
| fuchsia_component::Event stopped_event; | |
| stopped_event.header() = std::move(stopped_header); | |
| fuchsia_component::StoppedPayload stopped_payload; | |
| stopped_payload.exit_code(0); | |
| stopped_event.payload() = | |
| fuchsia_component::EventPayload::WithStopped(std::move(stopped_payload)); | |
| zircon_component_manager->OnComponentEvent(std::move(stopped_event)); | |
| EXPECT_TRUE(system_interface.GetComponentManager().FindComponentInfo(kExpectedKoid).empty()); | |
| // Inject a non-ELF component. | |
| fuchsia_component::EventHeader non_elf_header; | |
| non_elf_header.component_url(kNonElfUrl); | |
| non_elf_header.moniker(kNonElfMoniker); | |
| non_elf_header.event_type(fuchsia_component::EventType::kDebugStarted); | |
| fuchsia_component::Event non_elf_event; | |
| non_elf_event.header() = std::move(non_elf_header); | |
| ASSERT_EQ(zx_eventpair_create(0, left.reset_and_get_address(), right.reset_and_get_address()), | |
| ZX_OK); | |
| fuchsia_component::DebugStartedPayload non_elf_payload; | |
| non_elf_payload.runtime_dir() = std::nullopt; | |
| non_elf_payload.break_on_start() = std::move(right); | |
| non_elf_event.payload() = | |
| fuchsia_component::EventPayload::WithDebugStarted(std::move(non_elf_payload)); | |
| zircon_component_manager->OnComponentEvent(std::move(non_elf_event)); | |
| loop().WatchEventPair(left.get(), this, &handle); | |
| loop().Run(); | |
| // Still shouldn't have any ELF component info. | |
| EXPECT_TRUE(system_interface.GetComponentManager().FindComponentInfo(kExpectedKoid).empty()); | |
| ASSERT_EQ(system_interface.GetComponentManager().GetNonElfComponentInfo().size(), 1u); | |
| const auto& it = system_interface.GetComponentManager().GetNonElfComponentInfo().begin(); | |
| ASSERT_NE(it, system_interface.GetComponentManager().GetNonElfComponentInfo().end()); | |
| const auto& component_info = it->second; | |
| EXPECT_EQ(component_info.moniker, kNonElfMoniker); | |
| EXPECT_EQ(component_info.url, kNonElfUrl); | |
| fuchsia_component::EventHeader non_elf_stopped_header; | |
| non_elf_stopped_header.component_url(kNonElfUrl); | |
| non_elf_stopped_header.moniker(kNonElfMoniker); | |
| non_elf_stopped_header.event_type(fuchsia_component::EventType::kStopped); | |
| fuchsia_component::Event non_elf_stopped_event; | |
| non_elf_stopped_event.header() = std::move(non_elf_stopped_header); | |
| fuchsia_component::StoppedPayload non_elf_stopped_payload; | |
| non_elf_stopped_payload.exit_code(0); | |
| non_elf_stopped_event.payload() = | |
| fuchsia_component::EventPayload::WithStopped(std::move(non_elf_stopped_payload)); | |
| zircon_component_manager->OnComponentEvent(std::move(non_elf_stopped_event)); | |
| loop().RunUntilNoTasks(); | |
| EXPECT_TRUE(zircon_component_manager->GetNonElfComponentInfo().empty()); | |
| } | |
| TEST_F(ZirconSystemInterfaceTest, DelayedRuntimeDirServing) { | |
| ZirconSystemInterface system_interface; | |
| ZirconComponentManager* zircon_component_manager = &system_interface.zircon_component_manager(); | |
| constexpr char kElfMoniker[] = "test_wrapper/test:test_root"; | |
| constexpr char kElfUrl[] = "fuchsia-pkg://fuchsia.com/crasher_test#meta/rust_crasher_test.cm"; | |
| constexpr zx_koid_t kExpectedKoid = 42; | |
| auto helper = std::make_shared<testing::RuntimeDirHelper>(); | |
| helper->AddJobIdFile(kExpectedKoid); | |
| helper->Start(loop().dispatcher()); | |
| // Component manager dispatches DebugStarted before a cold test runner begins serving the | |
| // component's runtime directory. Serve the directory endpoint after more than one second to | |
| // verify ReadElfJobId waits long enough for cold runner startup. | |
| auto [runtime_client, runtime_server] = fidl::Endpoints<fuchsia_io::Directory>::Create(); | |
| fuchsia_component::EventHeader header; | |
| header.component_url(kElfUrl); | |
| header.moniker(kElfMoniker); | |
| header.event_type(fuchsia_component::EventType::kDebugStarted); | |
| fuchsia_component::Event event; | |
| event.header() = std::move(header); | |
| zx::eventpair left, right; | |
| ASSERT_EQ(zx_eventpair_create(0, left.reset_and_get_address(), right.reset_and_get_address()), | |
| ZX_OK); | |
| fuchsia_component::DebugStartedPayload payload; | |
| payload.runtime_dir() = std::move(runtime_client); | |
| payload.break_on_start() = std::move(right); | |
| event.payload() = fuchsia_component::EventPayload::WithDebugStarted(std::move(payload)); | |
| zircon_component_manager->OnComponentEvent(std::move(event)); | |
| loop().PostTimer(FROM_HERE, 1200, [helper, server = std::move(runtime_server)] mutable { | |
| helper->ServeScopedDirectory(kExpectedKoid, std::move(server)); | |
| }); | |
| debug::MessageLoop::WatchHandle handle; | |
| loop().WatchEventPair(left.get(), this, &handle); | |
| loop().Run(); | |
| const auto& info = system_interface.GetComponentManager().FindComponentInfo(kExpectedKoid); | |
| ASSERT_EQ(info.size(), 1u); | |
| EXPECT_EQ(info[0].moniker, kElfMoniker); | |
| EXPECT_EQ(info[0].url, kElfUrl); | |
| } | |
| TEST_F(ZirconSystemInterfaceTest, FilterMatchComponentsNonElf) { | |
| ZirconSystemInterface system_interface; | |
| constexpr char kMoniker[] = "some/absolute/moniker"; | |
| constexpr char kUrl[] = "fuchsia-pkg://fuchsia.com/component2#meta/component2.cm"; | |
| // Inject a non-ELF component. | |
| fuchsia_component::EventHeader header; | |
| header.component_url(kUrl); | |
| header.moniker(kMoniker); | |
| header.event_type(fuchsia_component::EventType::kDebugStarted); | |
| fuchsia_component::Event event; | |
| event.header() = std::move(header); | |
| fuchsia_component::DebugStartedPayload payload; | |
| payload.runtime_dir() = std::nullopt; | |
| event.payload() = fuchsia_component::EventPayload::WithDebugStarted(std::move(payload)); | |
| system_interface.zircon_component_manager().OnComponentEvent(std::move(event)); | |
| std::vector<debug_ipc::ComponentInfo> component_info; | |
| std::ranges::transform(system_interface.GetComponentManager().GetNonElfComponentInfo(), | |
| std::back_inserter(component_info), | |
| [](const auto& pair) -> debug_ipc::ComponentInfo { return pair.second; }); | |
| ASSERT_EQ(component_info.size(), 1u); | |
| debug_ipc::Filter moniker_filter; | |
| moniker_filter.type = debug_ipc::Filter::Type::kComponentMoniker; | |
| moniker_filter.pattern = kMoniker; | |
| EXPECT_TRUE(debug_ipc::FilterMatches(moniker_filter, "", component_info)); | |
| debug_ipc::Filter url_filter; | |
| url_filter.type = debug_ipc::Filter::Type::kComponentUrl; | |
| url_filter.pattern = kUrl; | |
| EXPECT_TRUE(debug_ipc::FilterMatches(url_filter, "", component_info)); | |
| } | |
| } // namespace | |
| TEST_F(ZirconSystemInterfaceTest, FilterMatchComponents) { | |
| ZirconSystemInterface system_interface; | |
| // Create a job tree like this: | |
| // 1: root-job | |
| // 2: child_job1 fake/moniker | |
| // ... | |
| // 5: child_job2 other/moniker | |
| // ... | |
| constexpr zx_koid_t kRootJobKoid = 1; | |
| constexpr zx_koid_t kChildJob1Koid = 2; | |
| constexpr zx_koid_t kChildJob2Koid = 5; | |
| auto& parent_jobs = system_interface.parent_jobs_; | |
| parent_jobs.insert({kChildJob1Koid, kRootJobKoid}); | |
| parent_jobs.insert({kChildJob2Koid, kRootJobKoid}); | |
| auto& component_info = system_interface.zircon_component_manager().running_component_info_; | |
| component_info.insert({kChildJob1Koid, | |
| { | |
| .moniker = "fake/moniker", | |
| .url = "fuchsia-pkg://fuchsia.com/component1#meta/component.cm", | |
| }}); | |
| component_info.insert({kChildJob2Koid, | |
| { | |
| .moniker = "other/moniker", | |
| .url = "fuchsia-pkg://fuchsia.com/some_other#meta/other_component.cm", | |
| }}); | |
| system_interface.zircon_component_manager().SetReadyCallback([&]() { loop().QuitNow(); }); | |
| loop().Run(); | |
| debug_ipc::Filter filter{ | |
| .type = debug_ipc::Filter::Type::kComponentName, | |
| .pattern = "component.cm", | |
| }; | |
| auto components = system_interface.GetComponentManager().FindComponentInfo(kChildJob1Koid); | |
| EXPECT_EQ(components.size(), 1u); | |
| EXPECT_TRUE(debug_ipc::FilterMatches(filter, "", components)); | |
| filter = { | |
| .type = debug_ipc::Filter::Type::kComponentUrl, | |
| .pattern = "fuchsia-pkg://fuchsia.com/some_other#meta/other_component.cm", | |
| }; | |
| components = system_interface.GetComponentManager().FindComponentInfo(kChildJob2Koid); | |
| EXPECT_EQ(components.size(), 1u); | |
| EXPECT_TRUE(debug_ipc::FilterMatches(filter, "", components)); | |
| } | |
| } // namespace debug_agent |