zircon/system/core/devmgr/devcoordinator/composite-device.cpp - fuchsia - Git at Google

 // Copyright 2019 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 "composite-device.h"

 #include <utility>
 #include <zircon/status.h>
 #include "../shared/log.h"
 #include "binding-internal.h"
 #include "coordinator.h"
 #include "fidl.h"

 namespace devmgr {

 // CompositeDevice methods

 CompositeDevice::CompositeDevice(fbl::String name, fbl::Array<const zx_device_prop_t> properties,
                                  uint32_t components_count, uint32_t coresident_device_index)
     : name_(std::move(name)), properties_(std::move(properties)),
       components_count_(components_count), coresident_device_index_(coresident_device_index) {
 }

 CompositeDevice::~CompositeDevice() = default;

 zx_status_t CompositeDevice::Create(const fbl::StringPiece& name,
                                     const zx_device_prop_t* props_data, size_t props_count,
                                     const fuchsia_device_manager_DeviceComponent* components,
                                     size_t components_count, uint32_t coresident_device_index,
                                     std::unique_ptr<CompositeDevice>* out) {
     if (components_count > UINT32_MAX) {
         return ZX_ERR_INVALID_ARGS;
     }

     fbl::String name_obj(name);
     fbl::Array<zx_device_prop_t> properties(new zx_device_prop_t[props_count], props_count);
     memcpy(properties.get(), props_data, props_count * sizeof(props_data[0]));

     auto dev = std::make_unique<CompositeDevice>(std::move(name), std::move(properties),
                                                  components_count, coresident_device_index);
     for (uint32_t i = 0; i < components_count; ++i) {
         const auto& fidl_component = components[i];
         size_t parts_count = fidl_component.parts_count;
         fbl::Array<ComponentPartDescriptor> parts(new ComponentPartDescriptor[parts_count],
                                                   parts_count);
         for (size_t j = 0; j < parts_count; ++j) {
             const auto& fidl_part = fidl_component.parts[j];
             size_t program_count = fidl_part.match_program_count;
             fbl::Array<zx_bind_inst_t> match_program(new zx_bind_inst_t[program_count],
                                                     program_count);
             static_assert(sizeof(zx_bind_inst_t) == sizeof(fidl_part.match_program[0]));
             memcpy(match_program.get(), fidl_part.match_program,
                    sizeof(zx_bind_inst_t) * program_count);
             parts[j] = { std::move(match_program) };
         }

         auto component = std::make_unique<CompositeDeviceComponent>(dev.get(), i, std::move(parts));
         dev->unbound_.push_back(std::move(component));
     }
     *out = std::move(dev);
     return ZX_OK;
 }

 bool CompositeDevice::TryMatchComponents(const fbl::RefPtr<Device>& dev, size_t* index_out) {
     for (auto itr = bound_.begin(); itr != bound_.end(); ++itr) {
         if (itr->TryMatch(dev)) {
             log(ERROR,
                 "devcoordinator: ambiguous composite bind! composite='%s', dev1='%s', dev2='%s'\n",
                 name_.data(), itr->bound_device()->name().data(), dev->name().data());
             return false;
         }
     }
     for (auto itr = unbound_.begin(); itr != unbound_.end(); ++itr) {
         if (itr->TryMatch(dev)) {
             log(SPEW, "devcoordinator: found match for composite='%s', dev='%s'\n",
                 name_.data(), dev->name().data());
             *index_out = itr->index();
            return true;
         }
     }
     log(SPEW, "devcoordinator: no match for composite='%s', dev='%s'\n",
         name_.data(), dev->name().data());
     return false;
 }

 zx_status_t CompositeDevice::BindComponent(size_t index, const fbl::RefPtr<Device>& dev) {
     // Find the component we're binding
     CompositeDeviceComponent* component = nullptr;
     for (auto& unbound_component : unbound_) {
         if (unbound_component.index() == index) {
             component = &unbound_component;
             break;
         }
     }
     ZX_ASSERT_MSG(component != nullptr, "Attempted to bind component that wasn't unbound!\n");

     zx_status_t status = component->Bind(dev);
     if (status != ZX_OK) {
         return status;
     }
     bound_.push_back(unbound_.erase(*component));
     return ZX_OK;
 }

 zx_status_t CompositeDevice::TryAssemble() {
     ZX_ASSERT(device_ == nullptr);
     if (!unbound_.is_empty()) {
         return ZX_ERR_SHOULD_WAIT;
     }

     Devhost* devhost = nullptr;
     for (auto& component : bound_) {
         // Find the devhost to put everything in (if we don't find one, nullptr
         // means "a new devhost").
         if (component.index() == coresident_device_index_) {
             devhost = component.bound_device()->host();
         }
         // Make sure the component driver has created its device
         if (component.component_device() == nullptr) {
             return ZX_ERR_SHOULD_WAIT;
         }
     }

     Coordinator* coordinator = nullptr;
     uint64_t component_local_ids[fuchsia_device_manager_COMPONENTS_MAX] = {};

     // Create all of the proxies for the component devices, in the same process
     for (auto& component : bound_) {
         const auto& component_dev = component.component_device();
         auto bound_dev = component.bound_device();
         coordinator = component_dev->coordinator;

         // If the device we're bound to is proxied, we care about its proxy
         // rather than it, since that's the side that we communicate with.
         if (bound_dev->proxy()) {
             bound_dev = bound_dev->proxy();
         }

         // Check if we need to use the proxy.  If not, share a reference straight
         // to the target device rather than the instance of the component device
         // that bound to it.
         if (bound_dev->host() == devhost) {
             component_local_ids[component.index()] = bound_dev->local_id();
             continue;
         }

         // We need to create it.  Double check that we haven't ended up in a state
         // where the proxies would need to be in different processes.
         if (devhost != nullptr && component_dev->proxy() != nullptr &&
             component_dev->proxy()->host() != nullptr &&
             component_dev->proxy()->host() != devhost) {
             log(ERROR, "devcoordinator: cannot create composite, proxies in different processes\n");
             return ZX_ERR_BAD_STATE;
         }

         zx_status_t status = coordinator->PrepareProxy(component_dev, devhost);
         if (status != ZX_OK) {
             return status;
         }
         // If we hadn't picked a devhost, use the one that was created just now.
         if (devhost == nullptr) {
             devhost = component_dev->proxy()->host();
             ZX_ASSERT(devhost != nullptr);
         }
         // Stash the local ID after the proxy has been created
         component_local_ids[component.index()] = component_dev->proxy()->local_id();
     }

     zx::channel rpc_local, rpc_remote;
     zx_status_t status = zx::channel::create(0, &rpc_local, &rpc_remote);
     if (status != ZX_OK) {
         return status;
     }

     fbl::RefPtr<Device> new_device;
     status = Device::CreateComposite(coordinator, devhost, *this, std::move(rpc_local),
                                      &new_device);
     if (status != ZX_OK) {
         return status;
     }
     coordinator->devices().push_back(new_device);

     // Create the composite device in the devhost
     status = dh_send_create_composite_device(devhost, new_device.get(), *this, component_local_ids,
                                              std::move(rpc_remote));
     if (status != ZX_OK) {
         log(ERROR, "devcoordinator: create composite device request failed: %s\n",
             zx_status_get_string(status));
         return status;
     }

     device_ = std::move(new_device);
     device_->set_composite(this);

     status = device_->SignalReadyForBind();
     if (status != ZX_OK) {
         return status;
     }

     return ZX_OK;
 }

 void CompositeDevice::UnbindComponent(CompositeDeviceComponent* component) {
     // If the composite was fully instantiated, diassociate from it.  It will be
     // reinstantiated when this component is re-bound.
     if (device_ != nullptr) {
         Remove();
     }
     ZX_ASSERT(device_ == nullptr);
     ZX_ASSERT(component->composite() == this);
     unbound_.push_back(bound_.erase(*component));
 }

 void CompositeDevice::Remove() {
     device_->disassociate_from_composite();
     device_ = nullptr;
 }

 // CompositeDeviceComponent methods

 CompositeDeviceComponent::CompositeDeviceComponent(CompositeDevice* composite, uint32_t index,
                                                    fbl::Array<const ComponentPartDescriptor> parts)
     : composite_(composite), index_(index), parts_(std::move(parts)) {
 }

 CompositeDeviceComponent::~CompositeDeviceComponent() = default;

 bool CompositeDeviceComponent::TryMatch(const fbl::RefPtr<Device>& dev) {
     if (parts_.size() > UINT32_MAX) {
         return false;
     }
     auto match = ::devmgr::internal::MatchParts(dev, parts_.get(),
                                                 static_cast<uint32_t>(parts_.size()));
     if (match != ::devmgr::internal::Match::One) {
         return false;
     }
     return true;
 }

 zx_status_t CompositeDeviceComponent::Bind(const fbl::RefPtr<Device>& dev) {
     ZX_ASSERT(bound_device_ == nullptr);

     zx_status_t status = dev->coordinator->BindDriverToDevice(
             dev, dev->coordinator->component_driver(), true /* autobind */);
     if (status != ZX_OK) {
         return status;
     }

     bound_device_ = dev;
     dev->set_component(this);
     return ZX_OK;
 }

 void CompositeDeviceComponent::Unbind() {
     ZX_ASSERT(bound_device_ != nullptr);
     composite_->UnbindComponent(this);
     // Drop our reference to the device added by the component driver
     component_device_ = nullptr;
     bound_device_->disassociate_from_composite();
     bound_device_ = nullptr;
 }

 } // namespace devmgr
	// Copyright 2019 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 "composite-device.h"

	#include <utility>
	#include <zircon/status.h>
	#include "../shared/log.h"
	#include "binding-internal.h"
	#include "coordinator.h"
	#include "fidl.h"

	namespace devmgr {

	// CompositeDevice methods

	CompositeDevice::CompositeDevice(fbl::String name, fbl::Array<const zx_device_prop_t> properties,
	uint32_t components_count, uint32_t coresident_device_index)
	: name_(std::move(name)), properties_(std::move(properties)),
	components_count_(components_count), coresident_device_index_(coresident_device_index) {
	}

	CompositeDevice::~CompositeDevice() = default;

	zx_status_t CompositeDevice::Create(const fbl::StringPiece& name,
	const zx_device_prop_t* props_data, size_t props_count,
	const fuchsia_device_manager_DeviceComponent* components,
	size_t components_count, uint32_t coresident_device_index,
	std::unique_ptr<CompositeDevice>* out) {
	if (components_count > UINT32_MAX) {
	return ZX_ERR_INVALID_ARGS;
	}

	fbl::String name_obj(name);
	fbl::Array<zx_device_prop_t> properties(new zx_device_prop_t[props_count], props_count);
	memcpy(properties.get(), props_data, props_count * sizeof(props_data[0]));

	auto dev = std::make_unique<CompositeDevice>(std::move(name), std::move(properties),
	components_count, coresident_device_index);
	for (uint32_t i = 0; i < components_count; ++i) {
	const auto& fidl_component = components[i];
	size_t parts_count = fidl_component.parts_count;
	fbl::Array<ComponentPartDescriptor> parts(new ComponentPartDescriptor[parts_count],
	parts_count);
	for (size_t j = 0; j < parts_count; ++j) {
	const auto& fidl_part = fidl_component.parts[j];
	size_t program_count = fidl_part.match_program_count;
	fbl::Array<zx_bind_inst_t> match_program(new zx_bind_inst_t[program_count],
	program_count);
	static_assert(sizeof(zx_bind_inst_t) == sizeof(fidl_part.match_program[0]));
	memcpy(match_program.get(), fidl_part.match_program,
	sizeof(zx_bind_inst_t) * program_count);
	parts[j] = { std::move(match_program) };
	}

	auto component = std::make_unique<CompositeDeviceComponent>(dev.get(), i, std::move(parts));
	dev->unbound_.push_back(std::move(component));
	}
	*out = std::move(dev);
	return ZX_OK;
	}

	bool CompositeDevice::TryMatchComponents(const fbl::RefPtr<Device>& dev, size_t* index_out) {
	for (auto itr = bound_.begin(); itr != bound_.end(); ++itr) {
	if (itr->TryMatch(dev)) {
	log(ERROR,
	"devcoordinator: ambiguous composite bind! composite='%s', dev1='%s', dev2='%s'\n",
	name_.data(), itr->bound_device()->name().data(), dev->name().data());
	return false;
	}
	}
	for (auto itr = unbound_.begin(); itr != unbound_.end(); ++itr) {
	if (itr->TryMatch(dev)) {
	log(SPEW, "devcoordinator: found match for composite='%s', dev='%s'\n",
	name_.data(), dev->name().data());
	*index_out = itr->index();
	return true;
	}
	}
	log(SPEW, "devcoordinator: no match for composite='%s', dev='%s'\n",
	name_.data(), dev->name().data());
	return false;
	}

	zx_status_t CompositeDevice::BindComponent(size_t index, const fbl::RefPtr<Device>& dev) {
	// Find the component we're binding
	CompositeDeviceComponent* component = nullptr;
	for (auto& unbound_component : unbound_) {
	if (unbound_component.index() == index) {
	component = &unbound_component;
	break;
	}
	}
	ZX_ASSERT_MSG(component != nullptr, "Attempted to bind component that wasn't unbound!\n");

	zx_status_t status = component->Bind(dev);
	if (status != ZX_OK) {
	return status;
	}
	bound_.push_back(unbound_.erase(*component));
	return ZX_OK;
	}

	zx_status_t CompositeDevice::TryAssemble() {
	ZX_ASSERT(device_ == nullptr);
	if (!unbound_.is_empty()) {
	return ZX_ERR_SHOULD_WAIT;
	}

	Devhost* devhost = nullptr;
	for (auto& component : bound_) {
	// Find the devhost to put everything in (if we don't find one, nullptr
	// means "a new devhost").
	if (component.index() == coresident_device_index_) {
	devhost = component.bound_device()->host();
	}
	// Make sure the component driver has created its device
	if (component.component_device() == nullptr) {
	return ZX_ERR_SHOULD_WAIT;
	}
	}

	Coordinator* coordinator = nullptr;
	uint64_t component_local_ids[fuchsia_device_manager_COMPONENTS_MAX] = {};

	// Create all of the proxies for the component devices, in the same process
	for (auto& component : bound_) {
	const auto& component_dev = component.component_device();
	auto bound_dev = component.bound_device();
	coordinator = component_dev->coordinator;

	// If the device we're bound to is proxied, we care about its proxy
	// rather than it, since that's the side that we communicate with.
	if (bound_dev->proxy()) {
	bound_dev = bound_dev->proxy();
	}

	// Check if we need to use the proxy. If not, share a reference straight
	// to the target device rather than the instance of the component device
	// that bound to it.
	if (bound_dev->host() == devhost) {
	component_local_ids[component.index()] = bound_dev->local_id();
	continue;
	}

	// We need to create it. Double check that we haven't ended up in a state
	// where the proxies would need to be in different processes.
	if (devhost != nullptr && component_dev->proxy() != nullptr &&
	component_dev->proxy()->host() != nullptr &&
	component_dev->proxy()->host() != devhost) {
	log(ERROR, "devcoordinator: cannot create composite, proxies in different processes\n");
	return ZX_ERR_BAD_STATE;
	}

	zx_status_t status = coordinator->PrepareProxy(component_dev, devhost);
	if (status != ZX_OK) {
	return status;
	}
	// If we hadn't picked a devhost, use the one that was created just now.
	if (devhost == nullptr) {
	devhost = component_dev->proxy()->host();
	ZX_ASSERT(devhost != nullptr);
	}
	// Stash the local ID after the proxy has been created
	component_local_ids[component.index()] = component_dev->proxy()->local_id();
	}

	zx::channel rpc_local, rpc_remote;
	zx_status_t status = zx::channel::create(0, &rpc_local, &rpc_remote);
	if (status != ZX_OK) {
	return status;
	}

	fbl::RefPtr<Device> new_device;
	status = Device::CreateComposite(coordinator, devhost, *this, std::move(rpc_local),
	&new_device);
	if (status != ZX_OK) {
	return status;
	}
	coordinator->devices().push_back(new_device);

	// Create the composite device in the devhost
	status = dh_send_create_composite_device(devhost, new_device.get(), *this, component_local_ids,
	std::move(rpc_remote));
	if (status != ZX_OK) {
	log(ERROR, "devcoordinator: create composite device request failed: %s\n",
	zx_status_get_string(status));
	return status;
	}

	device_ = std::move(new_device);
	device_->set_composite(this);

	status = device_->SignalReadyForBind();
	if (status != ZX_OK) {
	return status;
	}

	return ZX_OK;
	}

	void CompositeDevice::UnbindComponent(CompositeDeviceComponent* component) {
	// If the composite was fully instantiated, diassociate from it. It will be
	// reinstantiated when this component is re-bound.
	if (device_ != nullptr) {
	Remove();
	}
	ZX_ASSERT(device_ == nullptr);
	ZX_ASSERT(component->composite() == this);
	unbound_.push_back(bound_.erase(*component));
	}

	void CompositeDevice::Remove() {
	device_->disassociate_from_composite();
	device_ = nullptr;
	}

	// CompositeDeviceComponent methods

	CompositeDeviceComponent::CompositeDeviceComponent(CompositeDevice* composite, uint32_t index,
	fbl::Array<const ComponentPartDescriptor> parts)
	: composite_(composite), index_(index), parts_(std::move(parts)) {
	}

	CompositeDeviceComponent::~CompositeDeviceComponent() = default;

	bool CompositeDeviceComponent::TryMatch(const fbl::RefPtr<Device>& dev) {
	if (parts_.size() > UINT32_MAX) {
	return false;
	}
	auto match = ::devmgr::internal::MatchParts(dev, parts_.get(),
	static_cast<uint32_t>(parts_.size()));
	if (match != ::devmgr::internal::Match::One) {
	return false;
	}
	return true;
	}

	zx_status_t CompositeDeviceComponent::Bind(const fbl::RefPtr<Device>& dev) {
	ZX_ASSERT(bound_device_ == nullptr);

	zx_status_t status = dev->coordinator->BindDriverToDevice(
	dev, dev->coordinator->component_driver(), true /* autobind */);
	if (status != ZX_OK) {
	return status;
	}

	bound_device_ = dev;
	dev->set_component(this);
	return ZX_OK;
	}

	void CompositeDeviceComponent::Unbind() {
	ZX_ASSERT(bound_device_ != nullptr);
	composite_->UnbindComponent(this);
	// Drop our reference to the device added by the component driver
	component_device_ = nullptr;
	bound_device_->disassociate_from_composite();
	bound_device_ = nullptr;
	}

	} // namespace devmgr