| // Copyright 2022 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/devices/bin/driver_manager/driver_development/driver_development_service.h" | |
| #include <fidl/fuchsia.driver.framework/cpp/fidl.h> | |
| #include <lib/component/incoming/cpp/protocol.h> | |
| #include <algorithm> | |
| #include <queue> | |
| #include <unordered_map> | |
| #include <unordered_set> | |
| #include "src/devices/bin/driver_manager/driver_development/info_iterator.h" | |
| #include "src/devices/lib/log/log.h" | |
| namespace fdd = fuchsia_driver_development; | |
| namespace fdf { | |
| using namespace fuchsia_driver_framework; | |
| } | |
| namespace driver_manager { | |
| namespace { | |
| void SetNodeInfoBuilderNodeProperties( | |
| fidl::AnyArena& allocator, const driver_manager::Node& node, | |
| fidl::WireTableBuilder<fuchsia_driver_development::wire::NodeInfo> node_info_builder) { | |
| // Composite node's "default" node properties are its primary parent's node properties which | |
| // should not be used. | |
| if (node.type() == driver_manager::NodeType::kComposite) { | |
| return; | |
| } | |
| auto properties = node.GetNodeProperties(); | |
| // Avoid allocating an empty VectorView. | |
| if (!properties.has_value() || properties->empty()) { | |
| return; | |
| } | |
| fidl::VectorView<fdf::wire::NodeProperty2> node_properties(allocator, properties->size()); | |
| for (size_t i = 0; i < properties->size(); ++i) { | |
| node_properties[i] = fidl::ToWire(allocator, properties.value()[i]); | |
| } | |
| node_info_builder.node_property_list(node_properties); | |
| } | |
| zx::result<fdd::wire::NodeInfo> CreateDeviceInfo(fidl::AnyArena& allocator, | |
| const driver_manager::Node* node) { | |
| auto device_info = fdd::wire::NodeInfo::Builder(allocator); | |
| device_info.id(reinterpret_cast<uint64_t>(node)); | |
| const auto& children = node->children(); | |
| fidl::VectorView<uint64_t> child_ids(allocator, children.size()); | |
| size_t i = 0; | |
| for (const auto& child : children) { | |
| child_ids[i++] = reinterpret_cast<uint64_t>(child.get()); | |
| } | |
| if (!child_ids.empty()) { | |
| device_info.child_ids(child_ids); | |
| } | |
| const auto& parents = node->parents(); | |
| fidl::VectorView<uint64_t> parent_ids(allocator, parents.size()); | |
| i = 0; | |
| for (const auto& parent : parents) { | |
| auto parent_ptr = parent.lock(); | |
| if (!parent_ptr) { | |
| fdf_log::error("Parent node freed before it could be used"); | |
| return zx::error(ZX_ERR_INTERNAL); | |
| } | |
| parent_ids[i++] = reinterpret_cast<uint64_t>(parent_ptr.get()); | |
| } | |
| if (!parent_ids.empty()) { | |
| device_info.parent_ids(parent_ids); | |
| } | |
| device_info.moniker(fidl::StringView(allocator, node->MakeComponentMoniker())); | |
| device_info.topological_path(fidl::StringView(allocator, node->MakeTopologicalPath())); | |
| device_info.quarantined(node->quarantined()); | |
| device_info.is_running(node->is_running()); | |
| device_info.bound_driver_url(fidl::StringView(allocator, node->driver_url())); | |
| SetNodeInfoBuilderNodeProperties(allocator, *node, device_info); | |
| auto driver_host = node->driver_host(); | |
| if (node->is_bound() && driver_host) { | |
| auto result = driver_host->GetProcessKoid(); | |
| if (result.is_error()) { | |
| // ZX_ERR_SHOULD_WAIT means the driver host hasn't been fully connected to yet. | |
| // ZX_ERR_PEER_CLOSED means the host closed while we tried to query it. | |
| if (result.error_value() != ZX_ERR_SHOULD_WAIT && | |
| result.error_value() != ZX_ERR_PEER_CLOSED) { | |
| fdf_log::error("Failed to get the process KOID of a driver host: {}", | |
| zx_status_get_string(result.status_value())); | |
| return zx::error(result.status_value()); | |
| } | |
| } else { | |
| device_info.driver_host_koid(result.value()); | |
| } | |
| } | |
| // Copy over the offers. | |
| const std::vector<NodeOffer>& offers = node->offers(); | |
| if (!offers.empty()) { | |
| fidl::VectorView<fuchsia_component_decl::wire::Offer> node_offers(allocator, offers.size()); | |
| for (size_t i = 0; i < offers.size(); i++) { | |
| const NodeOffer& offer = offers[i]; | |
| switch (offer.transport) { | |
| case OfferTransport::DriverTransport: | |
| node_offers[i] = fidl::ToWire(allocator, ToFidl(offer).driver_transport().value()); | |
| break; | |
| case OfferTransport::ZirconTransport: | |
| node_offers[i] = fidl::ToWire(allocator, ToFidl(offer).zircon_transport().value()); | |
| break; | |
| case OfferTransport::Dictionary: | |
| node_offers[i] = fidl::ToWire(allocator, ToFidl(offer).dictionary_offer().value()); | |
| break; | |
| } | |
| } | |
| device_info.offer_list(node_offers); | |
| } | |
| std::vector topo_path = node->GetBusTopology(); | |
| device_info.bus_topology(fidl::ToWire(allocator, topo_path)); | |
| return zx::ok(device_info.Build()); | |
| } | |
| } // namespace | |
| DriverDevelopmentService::DriverDevelopmentService(driver_manager::DriverRunner& driver_runner, | |
| async_dispatcher_t* dispatcher) | |
| : driver_runner_(driver_runner), dispatcher_(dispatcher) {} | |
| void DriverDevelopmentService::Publish(component::OutgoingDirectory& outgoing) { | |
| auto result = outgoing.AddUnmanagedProtocol<fdd::Manager>( | |
| bindings_.CreateHandler(this, dispatcher_, [](fidl::UnbindInfo info) { | |
| if (!info.is_peer_closed()) { | |
| fdf_log::warn("development service closed. {}", info.FormatDescription()); | |
| } | |
| })); | |
| ZX_ASSERT(result.is_ok()); | |
| } | |
| void DriverDevelopmentService::GetNodeInfo(GetNodeInfoRequestView request, | |
| GetNodeInfoCompleter::Sync& completer) { | |
| auto arena = std::make_unique<fidl::Arena<512>>(); | |
| std::vector<fdd::wire::NodeInfo> device_infos; | |
| std::unordered_set<const driver_manager::Node*> unique_nodes; | |
| std::queue<const driver_manager::Node*> remaining_nodes; | |
| remaining_nodes.push(driver_runner_.root_node().get()); | |
| while (!remaining_nodes.empty()) { | |
| auto node = remaining_nodes.front(); | |
| remaining_nodes.pop(); | |
| auto [_, inserted] = unique_nodes.insert(node); | |
| if (!inserted) { | |
| // Only insert unique nodes from the DAG. | |
| continue; | |
| } | |
| const auto& children = node->children(); | |
| for (const auto& child : children) { | |
| remaining_nodes.push(child.get()); | |
| } | |
| std::string moniker = node->MakeComponentMoniker(); | |
| if (!request->node_filter.empty()) { | |
| bool found = false; | |
| for (const auto& node_filter : request->node_filter) { | |
| if (request->exact_match) { | |
| if (moniker == node_filter.get()) { | |
| found = true; | |
| break; | |
| } | |
| } else { | |
| if (moniker.find(node_filter.get()) != std::string::npos) { | |
| found = true; | |
| break; | |
| } | |
| } | |
| } | |
| if (!found) { | |
| continue; | |
| } | |
| } | |
| auto result = CreateDeviceInfo(*arena, node); | |
| if (result.is_error()) { | |
| return; | |
| } | |
| device_infos.push_back(std::move(result.value())); | |
| } | |
| auto iterator = std::make_unique<driver_development::DeviceInfoIterator>(std::move(arena), | |
| std::move(device_infos)); | |
| fidl::BindServer( | |
| this->dispatcher_, std::move(request->iterator), std::move(iterator), | |
| [](auto* self, fidl::UnbindInfo info, fidl::ServerEnd<fdd::NodeInfoIterator> server_end) { | |
| if (info.is_user_initiated()) { | |
| return; | |
| } | |
| if (info.is_peer_closed()) { | |
| // For this development protocol, the client is free to disconnect | |
| // at any time. | |
| return; | |
| } | |
| fdf_log::error("Error serving '{}': {}", fidl::DiscoverableProtocolName<fdd::Manager>, | |
| info.FormatDescription()); | |
| }); | |
| } | |
| void DriverDevelopmentService::GetCompositeInfo(GetCompositeInfoRequestView request, | |
| GetCompositeInfoCompleter::Sync& completer) { | |
| auto arena = std::make_unique<fidl::Arena<512>>(); | |
| std::vector<fdd::wire::CompositeNodeInfo> list = driver_runner_.GetCompositeListInfo(*arena); | |
| auto iterator = std::make_unique<driver_development::CompositeInfoIterator>(std::move(arena), | |
| std::move(list)); | |
| fidl::BindServer(this->dispatcher_, std::move(request->iterator), std::move(iterator), | |
| [](auto* server, fidl::UnbindInfo info, auto channel) { | |
| if (!info.is_peer_closed()) { | |
| fdf_log::warn("Closed CompositeInfoIterator: {}", info.lossy_description()); | |
| } | |
| }); | |
| } | |
| void DriverDevelopmentService::GetDriverInfo(GetDriverInfoRequestView request, | |
| GetDriverInfoCompleter::Sync& completer) { | |
| auto driver_index_client = component::Connect<fuchsia_driver_index::DevelopmentManager>(); | |
| if (driver_index_client.is_error()) { | |
| fdf_log::error("Failed to connect to service '{}': {}", | |
| fidl::DiscoverableProtocolName<fuchsia_driver_index::DevelopmentManager>, | |
| driver_index_client.status_string()); | |
| request->iterator.Close(driver_index_client.status_value()); | |
| return; | |
| } | |
| fidl::WireSyncClient driver_index{std::move(*driver_index_client)}; | |
| auto info_result = | |
| driver_index->GetDriverInfo(std::move(request->driver_filter), std::move(request->iterator)); | |
| if (!info_result.ok()) { | |
| fdf_log::error("Failed to call DriverIndex::GetDriverInfo: {}", info_result.error()); | |
| } | |
| } | |
| void DriverDevelopmentService::GetCompositeNodeSpecs( | |
| GetCompositeNodeSpecsRequestView request, GetCompositeNodeSpecsCompleter::Sync& completer) { | |
| auto driver_index_client = component::Connect<fuchsia_driver_index::DevelopmentManager>(); | |
| if (driver_index_client.is_error()) { | |
| fdf_log::error("Failed to connect to service '{}': {}", | |
| fidl::DiscoverableProtocolName<fuchsia_driver_index::DevelopmentManager>, | |
| driver_index_client.status_string()); | |
| request->iterator.Close(driver_index_client.status_value()); | |
| return; | |
| } | |
| fidl::WireSyncClient driver_index{std::move(*driver_index_client)}; | |
| auto info_result = | |
| driver_index->GetCompositeNodeSpecs(request->name_filter, std::move(request->iterator)); | |
| if (!info_result.ok()) { | |
| fdf_log::error("Failed to call DriverIndex::GetCompositeNodeSpecs: {}", info_result.error()); | |
| } | |
| } | |
| void DriverDevelopmentService::GetDriverHostInfo(GetDriverHostInfoRequestView request, | |
| GetDriverHostInfoCompleter::Sync& completer) { | |
| std::unordered_map<zx_koid_t, std::unordered_set<std::string>> driver_host_to_drivers; | |
| std::unordered_set<const driver_manager::Node*> unique_nodes; | |
| std::queue<const driver_manager::Node*> remaining_nodes; | |
| if (driver_runner_.root_node()) { | |
| remaining_nodes.push(driver_runner_.root_node().get()); | |
| } | |
| while (!remaining_nodes.empty()) { | |
| auto node = remaining_nodes.front(); | |
| remaining_nodes.pop(); | |
| if (!unique_nodes.insert(node).second) { | |
| continue; | |
| } | |
| for (const auto& child : node->children()) { | |
| remaining_nodes.push(child.get()); | |
| } | |
| if (node->is_bound()) { | |
| auto host = node->driver_host(); | |
| if (host) { | |
| auto koid_result = host->GetProcessKoid(); | |
| if (koid_result.is_ok()) { | |
| driver_host_to_drivers[koid_result.value()].insert(node->driver_url()); | |
| } | |
| } | |
| } | |
| } | |
| std::deque<fdd::DriverHostInfo> info; | |
| for (const auto& driver_host : driver_runner_.driver_hosts()) { | |
| zx::result process_info = driver_host.GetProcessInfo(); | |
| if (process_info.is_error()) { | |
| continue; | |
| } | |
| std::vector<fdd::ThreadInfo> threads; | |
| for (const auto& thread : process_info->threads()) { | |
| fdd::ThreadInfo thread_info{{ | |
| .koid = thread.koid(), | |
| .name = thread.name(), | |
| }}; | |
| if (!thread.scheduler_role().empty()) { | |
| thread_info.scheduler_role(thread.scheduler_role()); | |
| } | |
| threads.push_back(std::move(thread_info)); | |
| } | |
| std::vector<fdd::DispatcherInfo> dispatchers; | |
| for (const auto& dispatcher : process_info->dispatchers()) { | |
| std::optional<fdd::DispatcherState> state; | |
| switch (dispatcher.state()) { | |
| case fuchsia_driver_host::DispatcherState::kRunning: | |
| state = fdd::DispatcherState::kRunning; | |
| break; | |
| case fuchsia_driver_host::DispatcherState::kShuttingDown: | |
| state = fdd::DispatcherState::kShuttingDown; | |
| break; | |
| case fuchsia_driver_host::DispatcherState::kShutdown: | |
| state = fdd::DispatcherState::kShutdown; | |
| break; | |
| case fuchsia_driver_host::DispatcherState::kDestroyed: | |
| state = fdd::DispatcherState::kDestroyed; | |
| break; | |
| default: | |
| break; | |
| } | |
| std::vector<fdd::QueuedTaskInfo> queued_tasks; | |
| for (const auto& task : dispatcher.queued_tasks()) { | |
| fdd::QueuedTaskInfo task_info{{ | |
| .ptr = task.ptr(), | |
| .handler = task.handler(), | |
| .initiating_dispatcher = task.initiating_dispatcher(), | |
| .initiating_driver = task.initiating_driver(), | |
| }}; | |
| if (!task.initiating_dispatcher_name().empty()) { | |
| task_info.initiating_dispatcher_name(task.initiating_dispatcher_name()); | |
| } | |
| if (!task.initiating_driver_url().empty()) { | |
| task_info.initiating_driver_url(task.initiating_driver_url()); | |
| } | |
| queued_tasks.push_back(std::move(task_info)); | |
| } | |
| const auto& non_inlined = dispatcher.debug_stats().non_inlined(); | |
| fdd::DispatcherDebugStats debug_stats{{ | |
| .num_total_requests = dispatcher.debug_stats().num_total_requests(), | |
| .num_inlined_requests = dispatcher.debug_stats().num_inlined_requests(), | |
| .non_inlined = fdd::NonInlinedRequestStats{{ | |
| .allow_sync_calls = non_inlined.allow_sync_calls(), | |
| .parallel_dispatch = non_inlined.parallel_dispatch(), | |
| .task = non_inlined.task(), | |
| .unknown_thread = non_inlined.unknown_thread(), | |
| .reentrant = non_inlined.reentrant(), | |
| .channel_wait_not_yet_registered = non_inlined.channel_wait_not_yet_registered(), | |
| .no_thread_migration = non_inlined.no_thread_migration(), | |
| }}, | |
| }}; | |
| fdd::DispatcherInfo disp_info{{ | |
| .driver = dispatcher.driver(), | |
| .name = dispatcher.name(), | |
| .options = dispatcher.options(), | |
| .scheduler_role = dispatcher.scheduler_role(), | |
| .dispatcher_ptr = dispatcher.dispatcher_ptr(), | |
| .driver_ptr = dispatcher.driver_ptr(), | |
| .synchronized_ = dispatcher.synchronized_(), | |
| .allow_sync_calls = dispatcher.allow_sync_calls(), | |
| .state = state, | |
| .debug_stats = std::move(debug_stats), | |
| .queued_tasks = std::move(queued_tasks), | |
| .num_queued_tasks = dispatcher.num_queued_tasks(), | |
| }}; | |
| if (!dispatcher.destroy_context().empty()) { | |
| disp_info.destroy_context(dispatcher.destroy_context()); | |
| } | |
| if (dispatcher.has_destroy_user_initiated()) { | |
| disp_info.destroy_user_initiated(dispatcher.destroy_user_initiated()); | |
| } | |
| dispatchers.push_back(std::move(disp_info)); | |
| } | |
| std::vector<std::string> drivers; | |
| if (auto it = driver_host_to_drivers.find(process_info->process_koid()); | |
| it != driver_host_to_drivers.end()) { | |
| drivers.assign(it->second.begin(), it->second.end()); | |
| std::sort(drivers.begin(), drivers.end()); | |
| } | |
| info.emplace_back(fdd::DriverHostInfo{{ | |
| .process_koid = process_info->process_koid(), | |
| .threads = std::move(threads), | |
| .drivers = std::move(drivers), | |
| .dispatchers = std::move(dispatchers), | |
| .name = std::string(driver_host.name_for_colocation()), | |
| }}); | |
| } | |
| auto iterator = std::make_unique<driver_development::DriverHostInfoIterator>(std::move(info)); | |
| fidl::BindServer(this->dispatcher_, std::move(request->iterator), std::move(iterator), | |
| [](auto* self, fidl::UnbindInfo info, | |
| fidl::ServerEnd<fdd::DriverHostInfoIterator> server_end) { | |
| if (info.is_user_initiated()) { | |
| return; | |
| } | |
| if (info.is_peer_closed()) { | |
| // For this development protocol, the client is free to disconnect | |
| // at any time. | |
| return; | |
| } | |
| fdf_log::error("Error serving '{}': {}", | |
| fidl::DiscoverableProtocolName<fdd::Manager>, | |
| info.FormatDescription()); | |
| }); | |
| } | |
| void DriverDevelopmentService::DisableDriver(DisableDriverRequestView request, | |
| DisableDriverCompleter::Sync& completer) { | |
| auto driver_index_client = component::Connect<fuchsia_driver_index::DevelopmentManager>(); | |
| if (driver_index_client.is_error()) { | |
| fdf_log::error("Failed to connect to service '{}': {}", | |
| fidl::DiscoverableProtocolName<fuchsia_driver_index::DevelopmentManager>, | |
| driver_index_client.status_string()); | |
| completer.Close(driver_index_client.status_value()); | |
| return; | |
| } | |
| fidl::WireSyncClient driver_index{std::move(*driver_index_client)}; | |
| auto disable_result = driver_index->DisableDriver(request->driver_url, request->package_hash); | |
| if (!disable_result.ok()) { | |
| fdf_log::error("Failed to call DriverIndex::DisableDriver: {}", disable_result.error()); | |
| completer.Close(disable_result.error().status()); | |
| return; | |
| } | |
| completer.Reply(disable_result.value()); | |
| } | |
| void DriverDevelopmentService::EnableDriver(EnableDriverRequestView request, | |
| EnableDriverCompleter::Sync& completer) { | |
| auto driver_index_client = component::Connect<fuchsia_driver_index::DevelopmentManager>(); | |
| if (driver_index_client.is_error()) { | |
| fdf_log::error("Failed to connect to service '{}': {}", | |
| fidl::DiscoverableProtocolName<fuchsia_driver_index::DevelopmentManager>, | |
| driver_index_client.status_string()); | |
| completer.Close(driver_index_client.status_value()); | |
| return; | |
| } | |
| fidl::WireSyncClient driver_index{std::move(*driver_index_client)}; | |
| auto enable_result = driver_index->EnableDriver(request->driver_url, request->package_hash); | |
| if (!enable_result.ok()) { | |
| fdf_log::error("Failed to call DriverIndex::EnableDriver: {}", enable_result.error()); | |
| completer.Close(enable_result.error().status()); | |
| return; | |
| } | |
| completer.Reply(enable_result.value()); | |
| } | |
| void DriverDevelopmentService::RestartDriverHosts(RestartDriverHostsRequestView request, | |
| RestartDriverHostsCompleter::Sync& completer) { | |
| auto result = driver_runner_.RestartNodesColocatedWithDriverUrl(request->driver_url.get(), | |
| request->rematch_flags); | |
| if (result.is_ok()) { | |
| completer.ReplySuccess(result.value()); | |
| } else { | |
| completer.ReplyError(result.error_value()); | |
| } | |
| } | |
| void DriverDevelopmentService::BindAllUnboundNodes(BindAllUnboundNodesCompleter::Sync& completer) { | |
| auto callback = | |
| [completer = completer.ToAsync()]( | |
| fidl::VectorView<fuchsia_driver_development::wire::NodeBindingInfo> result) mutable { | |
| completer.ReplySuccess(result); | |
| }; | |
| driver_runner_.TryBindAllAvailable(std::move(callback)); | |
| } | |
| void DriverDevelopmentService::BindAllUnboundNodes2( | |
| BindAllUnboundNodes2Completer::Sync& completer) { | |
| auto callback = | |
| [completer = completer.ToAsync()]( | |
| fidl::VectorView<fuchsia_driver_development::wire::NodeBindingInfo> result) mutable { | |
| completer.ReplySuccess(result); | |
| }; | |
| driver_runner_.TryBindAllAvailable(std::move(callback)); | |
| } | |
| void DriverDevelopmentService::AddTestNode(AddTestNodeRequestView request, | |
| AddTestNodeCompleter::Sync& completer) { | |
| fuchsia_driver_framework::NodeAddArgs args; | |
| args.name(fidl::ToNatural(request->args.name())); | |
| args.properties2(fidl::ToNatural(request->args.properties())); | |
| driver_runner_.root_node()->AddChild( | |
| std::move(args), /* controller */ {}, /* node */ {}, | |
| [this, completer = completer.ToAsync()](fit::result<fuchsia_driver_framework::wire::NodeError, | |
| std::shared_ptr<driver_manager::Node>> | |
| result) mutable { | |
| if (result.is_error()) { | |
| completer.Reply(result.take_error()); | |
| } else { | |
| auto node = result.value(); | |
| test_nodes_[node->name()] = node; | |
| completer.ReplySuccess(); | |
| } | |
| }); | |
| } | |
| void DriverDevelopmentService::RemoveTestNode(RemoveTestNodeRequestView request, | |
| RemoveTestNodeCompleter::Sync& completer) { | |
| auto name = std::string(request->name.get()); | |
| if (test_nodes_.count(name) == 0) { | |
| completer.ReplyError(ZX_ERR_NOT_FOUND); | |
| return; | |
| } | |
| auto node = test_nodes_[name].lock(); | |
| if (!node) { | |
| completer.ReplySuccess(); | |
| test_nodes_.erase(name); | |
| return; | |
| } | |
| node->SetShouldDestroy(); | |
| node->Remove(driver_manager::RemovalSet::kAll, nullptr); | |
| test_nodes_.erase(name); | |
| completer.ReplySuccess(); | |
| } | |
| void DriverDevelopmentService::WaitForBootup(WaitForBootupCompleter::Sync& completer) { | |
| driver_runner_.WaitForBootup([completer = completer.ToAsync()]() mutable { completer.Reply(); }); | |
| } | |
| void DriverDevelopmentService::RestartWithDictionary( | |
| RestartWithDictionaryRequestView request, RestartWithDictionaryCompleter::Sync& completer) { | |
| zx::eventpair endpoint0, endpoint1; | |
| zx_status_t status = zx::eventpair::create(0, &endpoint0, &endpoint1); | |
| if (status != ZX_OK) { | |
| completer.ReplyError(status); | |
| return; | |
| } | |
| driver_runner_.RestartWithDictionary(std::move(request->moniker), std::move(request->dictionary), | |
| std::move(endpoint1)); | |
| completer.ReplySuccess(std::move(endpoint0)); | |
| } | |
| void DriverDevelopmentService::RestartWithDictionaryAndPowerDependencies( | |
| RestartWithDictionaryAndPowerDependenciesRequestView request, | |
| RestartWithDictionaryAndPowerDependenciesCompleter::Sync& completer) { | |
| zx::eventpair endpoint0, endpoint1; | |
| zx_status_t status = zx::eventpair::create(0, &endpoint0, &endpoint1); | |
| if (status != ZX_OK) { | |
| completer.ReplyError(status); | |
| return; | |
| } | |
| driver_runner_.RestartWithDictionaryAndPowerDependencies( | |
| std::string(request->moniker.get()), fidl::ToNatural(std::move(request->dictionary)), | |
| fidl::ToNatural(request->power_dependencies).value(), | |
| request->cpu_token_override.is_valid() | |
| ? std::make_optional(std::move(request->cpu_token_override)) | |
| : std::nullopt, | |
| fidl::ToNatural(std::move(request->node_power_token_overrides)) | |
| .value_or(std::vector<fuchsia_driver_development::NodePowerTokenOverride>{}), | |
| std::move(endpoint1)); | |
| completer.ReplySuccess(std::move(endpoint0)); | |
| } | |
| void DriverDevelopmentService::RebindCompositesWithDriver( | |
| RebindCompositesWithDriverRequestView request, | |
| RebindCompositesWithDriverCompleter::Sync& completer) { | |
| auto driver_index_client = component::Connect<fuchsia_driver_index::DevelopmentManager>(); | |
| if (driver_index_client.is_error()) { | |
| fdf_log::error("Failed to connect to service '{}': {}", | |
| fidl::DiscoverableProtocolName<fuchsia_driver_index::DevelopmentManager>, | |
| driver_index_client.status_string()); | |
| completer.Close(driver_index_client.status_value()); | |
| return; | |
| } | |
| fidl::WireSyncClient driver_index{std::move(*driver_index_client)}; | |
| auto index_rebind_result = driver_index->RebindCompositesWithDriver(request->driver_url); | |
| if (!index_rebind_result.ok()) { | |
| fdf_log::error("Failed to call DriverIndex::RebindCompositesWithDriver: {}", | |
| index_rebind_result.error()); | |
| completer.ReplyError(index_rebind_result.error().status()); | |
| return; | |
| } | |
| if (index_rebind_result.value().is_error()) { | |
| fdf_log::error("DriverIndex::RebindCompositesWithDriver failed: {}", | |
| zx_status_get_string(index_rebind_result.value().error_value())); | |
| completer.ReplyError(index_rebind_result.value().error_value()); | |
| return; | |
| } | |
| driver_runner_.RebindCompositesWithDriver( | |
| std::string(request->driver_url.get()), | |
| [completer = completer.ToAsync()](size_t count) mutable { | |
| completer.ReplySuccess(static_cast<uint32_t>(count)); | |
| }); | |
| } | |
| void DriverDevelopmentService::RunHealthCheck(RunHealthCheckRequestView request, | |
| RunHealthCheckCompleter::Sync& completer) { | |
| std::string target_moniker(request->moniker.get()); | |
| std::shared_ptr<driver_manager::Node> matched_node; | |
| std::unordered_set<const driver_manager::Node*> unique_nodes; | |
| std::queue<std::shared_ptr<driver_manager::Node>> remaining_nodes; | |
| if (driver_runner_.root_node()) { | |
| remaining_nodes.push(driver_runner_.root_node()); | |
| } | |
| while (!remaining_nodes.empty()) { | |
| auto node = remaining_nodes.front(); | |
| remaining_nodes.pop(); | |
| if (!unique_nodes.insert(node.get()).second) { | |
| continue; | |
| } | |
| // Only exact matches are accepted so that a request can never resolve to an unintended node. | |
| // If multiple nodes share a topological path, prefer a bound node. | |
| if (node->MakeComponentMoniker() == target_moniker || | |
| node->MakeTopologicalPath() == target_moniker) { | |
| matched_node = node; | |
| if (node->is_bound()) { | |
| break; | |
| } | |
| } | |
| for (const auto& child : node->children()) { | |
| remaining_nodes.push(child); | |
| } | |
| } | |
| if (!matched_node) { | |
| completer.ReplyError(fuchsia_driver_framework::wire::HealthCheckError::kNotFound); | |
| return; | |
| } | |
| matched_node->RunHealthCheck( | |
| request->request, | |
| [completer = completer.ToAsync()](fit::result<fuchsia_driver_framework::HealthCheckError, | |
| fuchsia_driver_framework::HealthCheckResponse> | |
| result) mutable { | |
| if (result.is_error()) { | |
| completer.ReplyError(result.error_value()); | |
| return; | |
| } | |
| fidl::Arena arena; | |
| completer.ReplySuccess(fidl::ToWire(arena, result.value())); | |
| }); | |
| } | |
| void DriverDevelopmentService::handle_unknown_method( | |
| fidl::UnknownMethodMetadata<fuchsia_driver_development::Manager> metadata, | |
| fidl::UnknownMethodCompleter::Sync& completer) { | |
| std::string method_type; | |
| switch (metadata.unknown_method_type) { | |
| case fidl::UnknownMethodType::kOneWay: | |
| method_type = "one-way"; | |
| break; | |
| case fidl::UnknownMethodType::kTwoWay: | |
| method_type = "two-way"; | |
| break; | |
| }; | |
| fdf_log::warn("DriverDevelopmentService received unknown {} method. Ordinal: {}", method_type, | |
| metadata.method_ordinal); | |
| } | |
| } // namespace driver_manager |