blob: 32b179416de8745be2dc6f586a5688f8a3ef43b1 [file]
// Copyright 2026 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.
use crate::devfs::ControllerAllowlistPassthrough;
use crate::node_manager::NodeManager;
use crate::serve::{ComponentControllerClientBinding, NodeControllerServerBinding};
use crate::shutdown::NodeBridge;
use crate::types::{DriverState, NodeDictionary, NodeState, NodeTypeVariant};
use driver_manager_devfs::DevfsDevice;
use driver_manager_driver_host::DriverHost;
use driver_manager_shutdown::{NodeRemovalTracker, NodeShutdownCoordinator, RemovalSet};
use driver_manager_types::{
Collection, NodeOffer, OfferTransport, ShutdownState, StartRequestReceiver,
};
use fidl_fuchsia_component_sandbox::AggregateSource;
use fidl_fuchsia_device_fs as fdevfs;
use fidl_fuchsia_driver_development as fdd;
use fidl_fuchsia_driver_framework as fdf;
use fidl_fuchsia_driver_host as fdh;
use flyweights::FlyStr;
use fuchsia_async::{self as fasync};
use futures::channel::oneshot;
use log::{debug, warn};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::{Rc, Weak};
#[derive(Clone)]
pub enum NodePropertyValue {
IntValue(u32),
StringValue(FlyStr),
BoolValue(bool),
EnumValue(FlyStr),
}
impl std::convert::From<fdf::NodePropertyValue> for NodePropertyValue {
fn from(source: fdf::NodePropertyValue) -> Self {
match source {
fdf::NodePropertyValue::IntValue(i) => Self::IntValue(i),
fdf::NodePropertyValue::StringValue(s) => Self::StringValue(FlyStr::new(s)),
fdf::NodePropertyValue::BoolValue(b) => Self::BoolValue(b),
fdf::NodePropertyValue::EnumValue(e) => Self::EnumValue(FlyStr::new(e)),
_ => unimplemented!(),
}
}
}
impl std::convert::From<NodePropertyValue> for fdf::NodePropertyValue {
fn from(source: NodePropertyValue) -> fdf::NodePropertyValue {
match source {
NodePropertyValue::IntValue(i) => fdf::NodePropertyValue::IntValue(i),
NodePropertyValue::StringValue(s) => fdf::NodePropertyValue::StringValue(s.to_string()),
NodePropertyValue::BoolValue(b) => fdf::NodePropertyValue::BoolValue(b),
NodePropertyValue::EnumValue(e) => fdf::NodePropertyValue::EnumValue(e.to_string()),
}
}
}
#[derive(Clone)]
pub struct NodeProperty {
pub key: FlyStr,
pub value: fdf::NodePropertyValue,
}
impl std::convert::From<fdf::NodeProperty2> for NodeProperty {
fn from(source: fdf::NodeProperty2) -> Self {
Self { key: FlyStr::new(source.key), value: source.value }
}
}
impl std::convert::From<NodeProperty> for fdf::NodeProperty2 {
fn from(source: NodeProperty) -> fdf::NodeProperty2 {
fdf::NodeProperty2 { key: source.key.to_string(), value: source.value }
}
}
#[derive(Clone)]
pub struct NodePropertyEntry {
pub name: String,
pub properties: Vec<NodeProperty>,
}
impl std::convert::From<fdf::NodePropertyEntry2> for NodePropertyEntry {
fn from(source: fdf::NodePropertyEntry2) -> Self {
Self {
name: source.name,
properties: source.properties.into_iter().map(|p| p.into()).collect(),
}
}
}
impl std::convert::From<NodePropertyEntry> for fdf::NodePropertyEntry2 {
fn from(source: NodePropertyEntry) -> fdf::NodePropertyEntry2 {
fdf::NodePropertyEntry2 {
name: source.name,
properties: source.properties.into_iter().map(|p| p.into()).collect(),
}
}
}
pub(crate) struct NodeDevfs {
pub(crate) device: DevfsDevice,
pub(crate) protocol_connector: Option<fdevfs::ConnectorProxy>,
pub(crate) controller_allowlist_passthrough: Option<Rc<ControllerAllowlistPassthrough>>,
}
impl NodeDevfs {
pub(crate) fn set_protocol_connector(&mut self, connector: fdevfs::ConnectorProxy) {
self.protocol_connector = Some(connector);
}
pub(crate) fn set_controller_allowlist_passthrough(
&mut self,
passthrough: Rc<ControllerAllowlistPassthrough>,
) {
self.controller_allowlist_passthrough = Some(passthrough);
}
pub(crate) fn set_device(&mut self, device: DevfsDevice) {
self.device = device;
}
pub(crate) fn device(&self) -> &DevfsDevice {
&self.device
}
}
pub(crate) struct NodeShutdown {
pub(crate) remove_complete_callback: Option<oneshot::Sender<()>>,
pub(crate) unbinding_children_completers: Vec<oneshot::Sender<Result<(), zx::Status>>>,
pub(crate) should_destroy_driver_component: bool,
}
impl NodeShutdown {
pub(crate) fn set_remove_complete_callback(&mut self, callback: oneshot::Sender<()>) {
self.remove_complete_callback = Some(callback);
}
pub(crate) fn push_unbinding_children_completer(
&mut self,
completer: oneshot::Sender<Result<(), zx::Status>>,
) {
self.unbinding_children_completers.push(completer);
}
pub(crate) fn unbinding_children_completers_len(&self) -> usize {
self.unbinding_children_completers.len()
}
pub(crate) fn has_remove_complete_callback(&self) -> bool {
self.remove_complete_callback.is_some()
}
pub(crate) fn take_remove_complete_callback(&mut self) -> Option<oneshot::Sender<()>> {
self.remove_complete_callback.take()
}
}
pub(crate) struct NodeBinding {
pub(crate) node_controller: Option<NodeControllerServerBinding>,
pub(crate) pending_bind_completer: Option<oneshot::Sender<Result<(), zx::Status>>>,
pub(crate) bind_error: Option<fdf::DriverResult>,
pub(crate) wait_for_driver_completer:
Option<oneshot::Sender<Result<fdf::DriverResult, zx::Status>>>,
pub(crate) restart_driver_url_suffix: Option<String>,
pub(crate) composite_rebind_completer: Option<oneshot::Sender<Result<(), zx::Status>>>,
}
impl NodeBinding {
pub(crate) fn on_match_error(&mut self, error: zx::Status) {
self.bind_error = Some(fdf::DriverResult::MatchError(error.into_raw()));
}
pub(crate) fn on_start_error(&mut self, error: zx::Status) {
self.bind_error = Some(fdf::DriverResult::StartError(error.into_raw()));
}
pub(crate) fn bind_error(&self) -> Option<fdf::DriverResult> {
match &self.bind_error {
Some(fdf::DriverResult::MatchError(s)) => Some(fdf::DriverResult::MatchError(*s)),
Some(fdf::DriverResult::StartError(s)) => Some(fdf::DriverResult::StartError(*s)),
_ => None,
}
}
pub(crate) fn has_pending_bind_completer(&self) -> bool {
self.pending_bind_completer.is_some()
}
pub(crate) fn has_wait_for_driver_completer(&self) -> bool {
self.wait_for_driver_completer.is_some()
}
pub(crate) fn node_controller_ref(&self) -> Option<fdf::NodeControllerControlHandle> {
self.node_controller.as_ref().map(|c| c.node_controller_ref.clone())
}
}
pub(crate) struct NodeComponent {
pub(crate) controller: ComponentControllerClientBinding,
pub(crate) start_request_receiver: Option<StartRequestReceiver>,
pub(crate) start_handles: Option<Vec<fidl_fuchsia_process::HandleInfo>>,
}
impl NodeComponent {
pub(crate) fn set_start_request_receiver(&mut self, receiver: StartRequestReceiver) {
self.start_request_receiver = Some(receiver);
}
pub(crate) fn take_start_request_receiver(&mut self) -> Option<StartRequestReceiver> {
self.start_request_receiver.take()
}
}
pub(crate) struct NodeDriverHost {
pub(crate) host: Option<Rc<dyn DriverHost>>,
pub(crate) name_for_colocation: String,
pub(crate) restart_on_crash: bool,
}
impl NodeDriverHost {
pub(crate) fn set_name_for_colocation(&mut self, name: &str) {
self.name_for_colocation = name.to_string();
}
pub(crate) fn set_host(&mut self, host: Rc<dyn DriverHost>) {
self.host = Some(host);
}
pub(crate) fn host(&self) -> Option<Rc<dyn DriverHost>> {
self.host.clone()
}
pub(crate) fn set_restart_on_crash(&mut self, value: bool) {
self.restart_on_crash = value;
}
}
pub(crate) struct NodeCore {
pub(crate) collection: Collection,
pub(crate) driver_package_type: fdf::DriverPackageType,
pub(crate) node_type: NodeTypeVariant,
pub(crate) children: Vec<Rc<Node>>,
pub(crate) properties: Vec<NodePropertyEntry>,
pub(crate) symbols: Vec<fdf::NodeSymbol>,
pub(crate) offers: Vec<NodeOffer>,
pub(crate) bus_info: Option<fdf::BusInfo>,
pub(crate) dictionary: NodeDictionary,
}
impl NodeCore {
pub(crate) fn set_subtree_dictionary(
&mut self,
dictionary: fidl_fuchsia_component_sandbox::CapabilityId,
) {
if matches!(self.dictionary, NodeDictionary::Standard(_)) {
panic!("Cannot set subtree dictionary on nodes with standard dictionaries");
}
self.dictionary = NodeDictionary::Subtree(dictionary);
}
pub(crate) fn remove_subtree_dictionary(&mut self) {
self.dictionary = NodeDictionary::None;
}
pub(crate) fn has_subtree_dictionary(&self) -> bool {
matches!(self.dictionary, NodeDictionary::Subtree(_))
}
pub(crate) fn set_collection(&mut self, collection: Collection) {
self.collection = collection;
}
pub(crate) fn set_driver_package_type(&mut self, package_type: fdf::DriverPackageType) {
self.driver_package_type = package_type;
}
pub(crate) fn is_composite(&self) -> bool {
matches!(self.node_type, NodeTypeVariant::Composite { .. })
}
pub(crate) fn dictionary_to_export(
&self,
) -> Option<fidl_fuchsia_component_sandbox::CapabilityId> {
match self.dictionary {
NodeDictionary::None => None,
NodeDictionary::Standard(d) => Some(d),
NodeDictionary::Subtree(d) => Some(d),
}
}
pub(crate) fn take_dictionary_offer_sources(
&mut self,
) -> HashMap<String, Vec<AggregateSource>> {
let mut sources = HashMap::<String, Vec<AggregateSource>>::new();
for dictionary_offer in self.offers.iter_mut() {
if !matches!(dictionary_offer.transport, OfferTransport::Dictionary) {
continue;
}
if let Some(connector) = dictionary_offer.dir_connector.take() {
sources.entry(dictionary_offer.service_name.clone()).or_default().push(
AggregateSource {
dir_connector: Some(connector),
source_instance_filter: Some(
dictionary_offer.source_instance_filter.clone(),
),
renamed_instances: Some(dictionary_offer.renamed_instances.clone()),
..Default::default()
},
);
}
}
sources
}
pub(crate) fn set_standard_dictionary(
&mut self,
dictionary: fidl_fuchsia_component_sandbox::CapabilityId,
) {
self.dictionary = NodeDictionary::Standard(dictionary);
}
pub(crate) fn parents(&self) -> Vec<Weak<Node>> {
match &self.node_type {
NodeTypeVariant::Normal { parent } => vec![parent.clone()],
NodeTypeVariant::Composite { parents, .. } => parents.clone(),
}
}
pub(crate) fn get_primary_parent(&self) -> Option<Rc<Node>> {
match &self.node_type {
NodeTypeVariant::Normal { parent } => parent.upgrade(),
NodeTypeVariant::Composite { parents, primary_index, .. } => {
parents.get(*primary_index as usize).and_then(|p| p.upgrade())
}
}
}
pub(crate) fn add_child(&mut self, child: Rc<Node>) {
self.children.push(child);
}
pub(crate) fn get_node_properties(
&self,
parent_name: Option<&str>,
) -> Option<Vec<fdf::NodeProperty2>> {
let parent_name = parent_name.unwrap_or("default");
for entry in self.properties.iter() {
if entry.name == parent_name {
return Some(entry.properties.clone().into_iter().map(|p| p.into()).collect());
}
}
None
}
pub(crate) fn set_symbols(&mut self, symbols: Vec<fdf::NodeSymbol>) {
self.symbols = symbols;
}
pub(crate) fn symbols(&self) -> &Vec<fdf::NodeSymbol> {
&self.symbols
}
pub(crate) fn offers(&self) -> &Vec<NodeOffer> {
&self.offers
}
pub(crate) fn set_offers(&mut self, offers: Vec<NodeOffer>) {
self.offers = offers;
}
pub(crate) fn reserve_offers(&mut self, additional: usize) {
self.offers.reserve(additional);
}
pub(crate) fn push_offer(&mut self, offer: NodeOffer) {
self.offers.push(offer);
}
pub(crate) fn set_bus_info(&mut self, bus_info: fdf::BusInfo) {
self.bus_info = Some(bus_info);
}
pub(crate) fn set_properties(&mut self, properties: Vec<NodePropertyEntry>) {
self.properties = properties;
}
pub(crate) fn clear_properties(&mut self) {
self.properties.clear();
}
pub(crate) fn push_property(&mut self, property: NodePropertyEntry) {
self.properties.push(property);
}
pub(crate) fn dictionary(&self) -> &NodeDictionary {
&self.dictionary
}
pub(crate) fn set_dictionary(&mut self, dictionary: NodeDictionary) {
self.dictionary = dictionary;
}
pub(crate) fn remove_child_from_children(&mut self, child: &Rc<Node>) -> bool {
self.children.retain(|c| !Rc::ptr_eq(c, child));
true
}
}
pub struct Node {
pub(crate) name: String,
pub(crate) node_manager: Box<dyn NodeManager>,
pub(crate) core: RefCell<NodeCore>,
pub(crate) state: RefCell<NodeState>,
pub(crate) devfs: RefCell<NodeDevfs>,
pub(crate) shutdown: RefCell<NodeShutdown>,
pub(crate) binding: RefCell<NodeBinding>,
pub(crate) component: RefCell<Option<NodeComponent>>,
pub(crate) driver_host: RefCell<NodeDriverHost>,
pub(crate) node_shutdown_coordinator: RefCell<NodeShutdownCoordinator>,
pub can_multibind_composites: bool,
pub(crate) weak_self: Weak<Self>,
pub(crate) scope: fasync::Scope,
}
impl Drop for Node {
fn drop(&mut self) {
debug!("Node: '{}' dropped", self.name());
}
}
impl Node {
pub fn new(name: &str, parent: Weak<Node>, node_manager: Box<dyn NodeManager>) -> Rc<Self> {
let driver_host = parent.upgrade().and_then(|p| p.host());
Rc::new_cyclic(|weak_self| {
let bridge = Box::new(NodeBridge::new(weak_self.clone()));
let enable_test_shutdown_delays = node_manager.is_test_shutdown_delay_enabled();
let shutdown_test_rng = node_manager.get_shutdown_test_rng();
Self {
name: name.to_string(),
node_manager,
core: RefCell::new(NodeCore {
collection: Collection::None,
driver_package_type: fdf::DriverPackageType::Base,
node_type: NodeTypeVariant::Normal { parent },
children: Vec::new(),
properties: Vec::new(),
symbols: Vec::new(),
offers: Vec::new(),
bus_info: None,
dictionary: NodeDictionary::None,
}),
state: RefCell::new(NodeState::Unbound),
devfs: RefCell::new(NodeDevfs {
device: DevfsDevice::new(),
protocol_connector: None,
controller_allowlist_passthrough: None,
}),
shutdown: RefCell::new(NodeShutdown {
remove_complete_callback: None,
unbinding_children_completers: Vec::new(),
should_destroy_driver_component: false,
}),
binding: RefCell::new(NodeBinding {
node_controller: None,
pending_bind_completer: None,
bind_error: None,
wait_for_driver_completer: None,
restart_driver_url_suffix: None,
composite_rebind_completer: None,
}),
component: RefCell::new(None),
driver_host: RefCell::new(NodeDriverHost {
host: driver_host,
name_for_colocation: String::new(),
restart_on_crash: false,
}),
node_shutdown_coordinator: RefCell::new(NodeShutdownCoordinator::new(
bridge,
enable_test_shutdown_delays,
shutdown_test_rng,
)),
can_multibind_composites: true,
weak_self: weak_self.clone(),
scope: fasync::Scope::new_with_name(format!("node:{name}")),
}
})
}
pub fn name(&self) -> &str {
&self.name
}
pub fn token_koid(&self) -> Option<zx::Koid> {
match &*self.state.borrow() {
NodeState::DriverComponent(driver_component) => Some(driver_component.instance_koid()),
_ => None,
}
}
pub fn make_topological_path(&self, deduplicate: bool) -> String {
let mut names = std::collections::VecDeque::new();
let mut current = Some(self.weak_self.upgrade().unwrap());
let mut prev_name = String::new();
while let Some(node) = current {
let name = node.name.clone();
if !deduplicate || name != prev_name {
names.push_front(name.clone());
prev_name = name;
}
current = node.get_primary_parent();
}
names.into_iter().collect::<Vec<_>>().join("/")
}
pub fn on_match_error(&self, error: zx::Status) {
self.binding.borrow_mut().on_match_error(error);
}
pub fn on_start_error(&self, error: zx::Status) {
self.binding.borrow_mut().on_start_error(error);
}
pub fn mark_as_composite_parent(&self) {
*self.state.borrow_mut() = NodeState::CompositeParent;
}
pub fn unmark_as_composite_parent(&self) {
*self.state.borrow_mut() = NodeState::Unbound;
}
pub(crate) fn is_pending_bind(&self) -> bool {
match &*self.state.borrow() {
NodeState::DriverComponent(component) => component.state == DriverState::Binding,
_ => false,
}
}
pub(crate) fn clear_driver_host(&self) {
if let NodeState::DriverComponent(ref mut component) = *self.state.borrow_mut() {
component.driver_client_binding.take();
}
}
pub fn make_component_moniker(&self) -> String {
let mut topo_path = self.make_topological_path(true);
let k_prefix = "dev/sys/platform/pt/";
let k_prefix2 = "dev/sys/platform/";
if topo_path == "dev" {
topo_path = "root".to_string();
} else if topo_path == "dev/sys/platform/pt" {
topo_path = "board".to_string();
} else if topo_path.starts_with(k_prefix) {
topo_path.replace_range(0..k_prefix.len(), "");
} else if topo_path.starts_with(k_prefix2) {
topo_path.replace_range(0..k_prefix2.len(), "");
}
topo_path.replace([':', '.'], "_").replace('/', ".")
}
pub fn children(&self) -> Vec<Rc<Node>> {
self.core.borrow().children.clone()
}
pub fn parents(&self) -> Vec<Weak<Node>> {
self.core.borrow().parents()
}
pub(crate) fn is_root_node(&self) -> bool {
self.make_topological_path(false) == "dev"
}
pub fn driver_url(&self) -> String {
match &*self.state.borrow() {
NodeState::Starting { driver_url } => driver_url.clone(),
NodeState::DriverComponent(c) => c.driver_url.clone(),
NodeState::Quarantined { driver_url } => driver_url.clone(),
NodeState::OwnedByParent { .. } => "owned by parent".to_string(),
NodeState::CompositeParent => "owned by composite(s)".to_string(),
NodeState::Unbound => "unbound".to_string(),
}
}
pub fn is_quarantined(&self) -> bool {
matches!(&*self.state.borrow(), NodeState::Quarantined { .. })
}
pub fn get_primary_parent(&self) -> Option<Rc<Node>> {
self.core.borrow().get_primary_parent()
}
pub fn get_bus_topology(&self) -> Vec<fdf::BusInfo> {
let mut segments = vec![];
let mut current = self.weak_self.upgrade();
while let Some(node) = current {
if let Some(bus_info) = node.core.borrow().bus_info.as_ref() {
segments.push(bus_info.clone());
}
current = node.get_primary_parent();
}
segments.reverse();
segments
}
pub fn get_node_properties(
&self,
parent_name: Option<&str>,
) -> Option<Vec<fdf::NodeProperty2>> {
self.core.borrow().get_node_properties(parent_name)
}
pub(crate) fn add_to_parents(&self) {
let this_node = self.weak_self.upgrade().unwrap();
for parent in self.parents() {
if let Some(p) = parent.upgrade() {
p.add_child_to_children(this_node.clone());
} else {
warn!("Parent freed before child {} could be added to it", self.name());
}
}
}
pub(crate) fn add_child_to_children(&self, child: Rc<Node>) {
self.core.borrow_mut().add_child(child);
}
pub fn add_child_to_children_for_testing(&self, child: Rc<Node>) {
self.add_child_to_children(child);
}
pub fn set_state_for_testing(&self, state: NodeState) {
self.set_state(state);
}
pub fn driver_host(&self) -> Option<Rc<dyn DriverHost>> {
self.driver_host.borrow().host()
}
pub fn is_composite(&self) -> bool {
self.core.borrow().is_composite()
}
pub fn is_bound(&self) -> bool {
matches!(&*self.state.borrow(), NodeState::DriverComponent { .. })
}
pub fn is_driver_running(&self) -> bool {
if self.shutdown_state() != ShutdownState::Running {
return false;
}
matches!(
&*self.state.borrow(),
NodeState::DriverComponent(component) if component.state == DriverState::Running
)
}
pub fn evaluate_rematch_flags(
&self,
rematch_flags: fdd::RestartRematchFlags,
url: &str,
) -> bool {
if self.core.borrow().is_composite()
&& !rematch_flags.contains(fdd::RestartRematchFlags::COMPOSITE_SPEC)
{
return false;
}
let driver_url = self.driver_url();
if driver_url == url && !rematch_flags.contains(fdd::RestartRematchFlags::REQUESTED) {
return false;
}
if driver_url != url && rematch_flags.contains(fdd::RestartRematchFlags::NON_REQUESTED) {
return false;
}
true
}
pub fn set_subtree_dictionary(&self, dictionary: fidl_fuchsia_component_sandbox::CapabilityId) {
self.core.borrow_mut().set_subtree_dictionary(dictionary);
}
pub fn remove_subtree_dictionary(&self) {
self.core.borrow_mut().remove_subtree_dictionary();
}
pub fn has_subtree_dictionary(&self) -> bool {
self.core.borrow().has_subtree_dictionary()
}
pub fn skip_injected_offers(&self) -> bool {
self.has_subtree_dictionary()
}
pub async fn prepare_dictionary(
&self,
) -> Option<fidl_fuchsia_component_sandbox::DictionaryRef> {
let dictionary_util = self.node_manager.get_dictionary_util().ok()?;
let to_export = self.core.borrow().dictionary_to_export();
if let Some(d) = to_export {
return dictionary_util.copy_export_dictionary(d).await.ok();
}
let sources = self.core.borrow_mut().take_dictionary_offer_sources();
let aggregate_dictionary =
dictionary_util.create_aggregate_dictionary(sources).await.ok()?;
self.core.borrow_mut().set_standard_dictionary(aggregate_dictionary);
dictionary_util.copy_export_dictionary(aggregate_dictionary).await.ok()
}
pub fn remove(
self: &Rc<Self>,
removal_set: RemovalSet,
removal_tracker: Option<Weak<RefCell<NodeRemovalTracker>>>,
) {
NodeShutdownCoordinator::remove(self.clone(), removal_set, removal_tracker);
}
pub(crate) fn get_shutdown_coordinator(
&self,
) -> std::cell::RefMut<'_, NodeShutdownCoordinator> {
self.node_shutdown_coordinator.borrow_mut()
}
pub fn weak_from_this(&self) -> Weak<Self> {
self.weak_self.clone()
}
pub fn collection(&self) -> Collection {
self.core.borrow().collection
}
pub fn set_collection(&self, collection: Collection) {
self.core.borrow_mut().set_collection(collection);
}
pub fn set_driver_package_type(&self, package_type: fdf::DriverPackageType) {
self.core.borrow_mut().set_driver_package_type(package_type);
}
pub fn set_driver_host_name_for_colocation(&self, name: &str) {
self.driver_host.borrow_mut().set_name_for_colocation(name);
}
pub fn node_type(&self) -> std::cell::Ref<'_, NodeTypeVariant> {
std::cell::Ref::map(self.core.borrow(), |core| &core.node_type)
}
pub(crate) fn set_symbols(&self, symbols: Vec<fdf::NodeSymbol>) {
self.core.borrow_mut().set_symbols(symbols);
}
pub fn symbols(&self) -> Vec<fdf::NodeSymbol> {
self.core.borrow().symbols().clone()
}
pub fn offers(&self) -> Vec<NodeOffer> {
self.core.borrow().offers().clone()
}
pub(crate) fn set_offers(&self, offers: Vec<NodeOffer>) {
self.core.borrow_mut().set_offers(offers);
}
pub(crate) fn reserve_offers(&self, additional: usize) {
self.core.borrow_mut().reserve_offers(additional);
}
pub(crate) fn push_offer(&self, offer: NodeOffer) {
self.core.borrow_mut().push_offer(offer);
}
pub(crate) fn set_bus_info(&self, bus_info: fdf::BusInfo) {
self.core.borrow_mut().set_bus_info(bus_info);
}
pub(crate) fn set_properties(&self, properties: Vec<NodePropertyEntry>) {
self.core.borrow_mut().set_properties(properties);
}
pub(crate) fn clear_properties(&self) {
self.core.borrow_mut().clear_properties();
}
pub(crate) fn push_property(&self, property: NodePropertyEntry) {
self.core.borrow_mut().push_property(property);
}
pub(crate) fn dictionary(&self) -> NodeDictionary {
self.core.borrow().dictionary().clone()
}
pub(crate) fn set_dictionary(&self, dictionary: NodeDictionary) {
self.core.borrow_mut().set_dictionary(dictionary);
}
pub(crate) fn set_node_controller(&self, controller: NodeControllerServerBinding) {
self.binding.borrow_mut().node_controller = Some(controller);
}
pub(crate) fn set_pending_bind_completer(
&self,
completer: oneshot::Sender<Result<(), zx::Status>>,
) {
self.binding.borrow_mut().pending_bind_completer = Some(completer);
}
pub(crate) fn take_pending_bind_completer(
&self,
) -> Option<oneshot::Sender<Result<(), zx::Status>>> {
self.binding.borrow_mut().pending_bind_completer.take()
}
pub(crate) fn set_wait_for_driver_completer(
&self,
completer: oneshot::Sender<Result<fdf::DriverResult, zx::Status>>,
) {
self.binding.borrow_mut().wait_for_driver_completer = Some(completer);
}
pub(crate) fn take_wait_for_driver_completer(
&self,
) -> Option<oneshot::Sender<Result<fdf::DriverResult, zx::Status>>> {
self.binding.borrow_mut().wait_for_driver_completer.take()
}
pub(crate) fn set_restart_driver_url_suffix(&self, suffix: String) {
self.binding.borrow_mut().restart_driver_url_suffix = Some(suffix);
}
pub fn set_host(&self, host: Rc<dyn DriverHost>) {
self.driver_host.borrow_mut().set_host(host);
}
pub(crate) fn host(&self) -> Option<Rc<dyn DriverHost>> {
self.driver_host.borrow().host()
}
pub(crate) fn set_restart_on_crash(&self, value: bool) {
self.driver_host.borrow_mut().set_restart_on_crash(value);
}
pub(crate) fn set_remove_complete_callback(&self, callback: oneshot::Sender<()>) {
self.shutdown.borrow_mut().set_remove_complete_callback(callback);
}
pub(crate) fn push_unbinding_children_completer(
&self,
completer: oneshot::Sender<Result<(), zx::Status>>,
) {
self.shutdown.borrow_mut().push_unbinding_children_completer(completer);
}
pub(crate) fn unbinding_children_completers_len(&self) -> usize {
self.shutdown.borrow().unbinding_children_completers_len()
}
pub(crate) fn set_protocol_connector(&self, connector: fdevfs::ConnectorProxy) {
self.devfs.borrow_mut().set_protocol_connector(connector);
}
pub(crate) fn set_controller_allowlist_passthrough(
&self,
passthrough: Rc<ControllerAllowlistPassthrough>,
) {
self.devfs.borrow_mut().set_controller_allowlist_passthrough(passthrough);
}
pub(crate) fn set_device(&self, device: DevfsDevice) {
self.devfs.borrow_mut().set_device(device);
}
pub(crate) fn device(&self) -> DevfsDevice {
self.devfs.borrow().device().clone()
}
pub(crate) fn set_start_request_receiver(&self, receiver: StartRequestReceiver) {
if let Some(ref mut component) = *self.component.borrow_mut() {
component.set_start_request_receiver(receiver);
}
}
pub(crate) fn take_start_request_receiver(&self) -> Option<StartRequestReceiver> {
if let Some(ref mut component) = *self.component.borrow_mut() {
component.take_start_request_receiver()
} else {
None
}
}
pub(crate) fn set_state(&self, state: NodeState) {
*self.state.borrow_mut() = state;
}
pub(crate) fn is_unbound(&self) -> bool {
matches!(&*self.state.borrow(), NodeState::Unbound)
}
pub(crate) fn is_running(&self) -> bool {
if let NodeState::DriverComponent(ref mut driver_component) = *self.state.borrow_mut() {
if driver_component.state == DriverState::Stopped {
warn!("completed bind but the driver is already stopped");
false
} else {
driver_component.state = DriverState::Running;
true
}
} else {
false
}
}
pub fn token_handle(&self) -> Option<zx::Event> {
if self.core.borrow().is_composite() {
self.core.borrow().children.iter().find_map(|child| {
if let NodeState::DriverComponent(driver_component) = &*child.state.borrow()
&& driver_component.state == DriverState::Running
{
Some(driver_component.duplicate_instance_handle())
} else {
None
}
})
} else if let NodeState::DriverComponent(driver_component) = &*self.state.borrow() {
if driver_component.state == DriverState::Running {
Some(driver_component.duplicate_instance_handle())
} else {
None
}
} else {
None
}
}
pub(crate) fn has_wait_for_driver_completer(&self) -> bool {
self.binding.borrow().has_wait_for_driver_completer()
}
pub(crate) fn bind_error(&self) -> Option<fdf::DriverResult> {
self.binding.borrow().bind_error()
}
pub(crate) fn has_pending_bind_completer(&self) -> bool {
self.binding.borrow().has_pending_bind_completer()
}
pub(crate) fn quarantine_start(&self) -> bool {
let mut state = self.state.borrow_mut();
match *state {
NodeState::DriverComponent(ref mut driver_component) => {
driver_component.close_node();
driver_component.driver_client_binding.take();
}
NodeState::Starting { .. } => {}
_ => {
return false;
}
}
let driver_url = match &*state {
NodeState::Starting { driver_url } => driver_url.clone(),
NodeState::DriverComponent(c) => c.driver_url.clone(),
_ => unreachable!(),
};
*state = NodeState::Quarantined { driver_url };
true
}
pub(crate) fn node_controller_ref(&self) -> Option<fdf::NodeControllerControlHandle> {
self.binding.borrow().node_controller_ref()
}
pub(crate) fn take_start_handles_for_start(&self) -> Vec<fidl_fuchsia_process::HandleInfo> {
let mut component = self.component.borrow_mut();
let component = component.as_mut().expect("component");
component
.start_handles
.take()
.expect("handles")
.iter()
.map(|h| fidl_fuchsia_process::HandleInfo {
handle: h
.handle
.duplicate_handle(zx::Rights::SAME_RIGHTS)
.expect("duplicate handle"),
id: h.id,
})
.collect::<Vec<_>>()
}
pub(crate) fn shutdown_state(&self) -> ShutdownState {
*self.node_shutdown_coordinator.borrow().node_state()
}
pub(crate) fn driver_host_name_for_colocation(&self) -> String {
self.driver_host.borrow().name_for_colocation.clone()
}
pub(crate) fn get_node_property_dict(&self) -> fdf::NodePropertyDictionary2 {
let core = self.core.borrow();
core.properties
.iter()
.map(|entry| fdf::NodePropertyEntry2 {
name: entry.name.clone(),
properties: entry.properties.clone().into_iter().map(|p| p.into()).collect(),
})
.collect()
}
pub(crate) fn driver_package_type(&self) -> fdf::DriverPackageType {
self.core.borrow().driver_package_type
}
pub fn has_component_controller_proxy(&self) -> bool {
self.component.borrow().is_some()
}
pub(crate) fn protocol_connector(&self) -> Option<fdevfs::ConnectorProxy> {
self.devfs.borrow().protocol_connector.clone()
}
pub(crate) fn controller_allowlist_passthrough(
&self,
) -> Option<Rc<ControllerAllowlistPassthrough>> {
self.devfs.borrow().controller_allowlist_passthrough.clone()
}
pub(crate) fn set_should_destroy_driver_component(&self, val: bool) {
self.shutdown.borrow_mut().should_destroy_driver_component = val;
}
pub(crate) fn take_component(&self) -> Option<crate::node::NodeComponent> {
self.component.borrow_mut().take()
}
pub(crate) fn set_component(&self, component: crate::node::NodeComponent) {
*self.component.borrow_mut() = Some(component);
}
pub(crate) fn take_node_controller(&self) -> Option<NodeControllerServerBinding> {
self.binding.borrow_mut().node_controller.take()
}
pub(crate) fn finish_shutdown_state(&self) {
match *self.state.borrow_mut() {
NodeState::DriverComponent(ref mut driver_component) => {
driver_component.close_node();
driver_component.driver_client_binding.take();
}
NodeState::OwnedByParent { ref mut node_server_binding } => {
if let Some(binding) = node_server_binding.take() {
binding.close()
}
}
_ => {}
}
self.devfs.borrow_mut().device.topological.take();
self.devfs.borrow_mut().device.protocol.take();
}
pub(crate) fn reset_node_type(&self) {
*self.state.borrow_mut() = NodeState::Unbound;
let mut core = self.core.borrow_mut();
match core.node_type {
NodeTypeVariant::Normal { .. } => {
core.node_type = NodeTypeVariant::Normal { parent: Weak::new() };
}
NodeTypeVariant::Composite { .. } => {
core.node_type = NodeTypeVariant::Composite {
parents: vec![],
parents_names: vec![],
primary_index: 0,
};
}
}
}
pub(crate) fn take_remove_complete_callback(&self) -> Option<oneshot::Sender<()>> {
self.shutdown.borrow_mut().take_remove_complete_callback()
}
pub(crate) fn take_composite_rebind_completer(
&self,
) -> Option<oneshot::Sender<Result<(), zx::Status>>> {
self.binding.borrow_mut().composite_rebind_completer.take()
}
pub(crate) fn finish_restart_state(&self) {
match *self.state.borrow_mut() {
NodeState::DriverComponent(ref mut driver_component) => {
driver_component.close_node();
driver_component.driver_client_binding.take();
}
NodeState::OwnedByParent { ref mut node_server_binding } => {
if let Some(binding) = node_server_binding.take() {
binding.close()
}
}
_ => {}
}
*self.state.borrow_mut() = NodeState::Unbound;
}
pub(crate) fn host_restart_on_crash(&self) -> bool {
self.driver_host.borrow().restart_on_crash
}
pub(crate) fn take_host(&self) -> Option<Rc<dyn DriverHost>> {
self.driver_host.borrow_mut().host.take()
}
pub(crate) fn take_restart_driver_url_suffix(&self) -> Option<String> {
self.binding.borrow_mut().restart_driver_url_suffix.take()
}
pub fn has_driver(&self) -> bool {
match &*self.state.borrow() {
NodeState::DriverComponent(component) => component.driver_client_binding.is_some(),
_ => false,
}
}
pub fn has_driver_component(&self) -> bool {
match &*self.state.borrow() {
NodeState::DriverComponent(component) => component.state != DriverState::Stopped,
_ => false,
}
}
pub(crate) fn stop_driver_component(&self) {
if self.has_driver_component() {
debug!(
"Node '{}' sending stop through component runner",
self.make_component_moniker()
);
self.send_on_stop();
}
}
pub(crate) fn remove_child_from_children(&self, child: &Rc<Node>) -> bool {
self.core.borrow_mut().remove_child_from_children(child)
}
pub(crate) fn driver_client_binding(&self) -> Option<fdh::DriverProxy> {
match &*self.state.borrow() {
NodeState::DriverComponent(component) => {
component.driver_client_binding.as_ref().map(|b| b.driver_host_proxy.clone())
}
_ => None,
}
}
pub(crate) fn send_on_stop(&self) {
if let NodeState::DriverComponent(ref driver_component) = *self.state.borrow() {
driver_component.send_on_stop();
}
}
pub(crate) fn should_destroy_driver_component(&self) -> bool {
self.shutdown.borrow().should_destroy_driver_component
}
pub(crate) fn has_remove_complete_callback(&self) -> bool {
self.shutdown.borrow().has_remove_complete_callback()
}
pub(crate) fn component_controller_proxy(
&self,
) -> Option<fidl_fuchsia_component::ControllerProxy> {
self.component.borrow().as_ref().map(|c| c.controller.component_controller_proxy.clone())
}
pub(crate) fn set_driver_stopped(&self) {
let mut state = self.state.borrow_mut();
if let NodeState::DriverComponent(ref mut driver_component) = *state {
driver_component.state = DriverState::Stopped;
}
}
pub(crate) fn set_composite_rebind_completer(
&self,
completer: oneshot::Sender<Result<(), zx::Status>>,
) -> Result<(), oneshot::Sender<Result<(), zx::Status>>> {
let mut binding = self.binding.borrow_mut();
if binding.composite_rebind_completer.is_some() {
return Err(completer);
}
binding.composite_rebind_completer = Some(completer);
Ok(())
}
}