| // 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 "device.h" |
| |
| #include <ddk/driver.h> |
| #include <fbl/auto_call.h> |
| #include <lib/fidl/coding.h> |
| #include "../shared/fidl_txn.h" |
| #include "../shared/log.h" |
| #include "coordinator.h" |
| #include "devfs.h" |
| #include "fidl.h" |
| #include "suspend-task.h" |
| |
| namespace devmgr { |
| |
| Device::Device(Coordinator* coord, fbl::String name, fbl::String libname, fbl::String args, |
| fbl::RefPtr<Device> parent, uint32_t protocol_id, zx::channel client_remote) |
| : coordinator(coord), name_(std::move(name)), libname_(std::move(libname)), |
| args_(std::move(args)), parent_(std::move(parent)), protocol_id_(protocol_id), |
| publish_task_([this] { coordinator->HandleNewDevice(fbl::WrapRefPtr(this)); }), |
| client_remote_(std::move(client_remote)) {} |
| |
| Device::~Device() { |
| // Ideally we'd assert here that immortal devices are never destroyed, but |
| // they're destroyed when the Coordinator object is cleaned up in tests. |
| // We can probably get rid of the IMMORTAL flag, since if the Coordinator is |
| // holding a reference we shouldn't be able to hit that check, in which case |
| // the flag is only used to modify the proxy library loading behavior. |
| |
| log(DEVLC, "devcoordinator: destroy dev %p name='%s'\n", this, name_.data()); |
| |
| devfs_unpublish(this); |
| |
| // Drop our reference to our devhost if we still have it |
| set_host(nullptr); |
| |
| fbl::unique_ptr<Metadata> md; |
| while ((md = metadata_.pop_front()) != nullptr) { |
| if (md->has_path) { |
| // return to published_metadata list |
| coordinator->AppendPublishedMetadata(std::move(md)); |
| } else { |
| // metadata was attached directly to this device, so we release it now |
| } |
| } |
| |
| // TODO: cancel any pending rpc responses |
| // TODO: Have dtor assert that DEV_CTX_IMMORTAL set on flags |
| } |
| |
| zx_status_t Device::Create(Coordinator* coordinator, const fbl::RefPtr<Device>& parent, |
| fbl::String name, fbl::String driver_path, fbl::String args, |
| uint32_t protocol_id, fbl::Array<zx_device_prop_t> props, |
| zx::channel rpc, bool invisible, zx::channel client_remote, |
| fbl::RefPtr<Device>* device) { |
| fbl::RefPtr<Device> real_parent; |
| // If our parent is a proxy, for the purpose of devfs, we need to work with |
| // *its* parent which is the device that it is proxying. |
| if (parent->flags & DEV_CTX_PROXY) { |
| real_parent = parent->parent(); |
| } else { |
| real_parent = parent; |
| } |
| |
| auto dev = fbl::MakeRefCounted<Device>(coordinator, std::move(name), std::move(driver_path), |
| std::move(args), real_parent, protocol_id, |
| std::move(client_remote)); |
| if (!dev) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| zx_status_t status = dev->SetProps(std::move(props)); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| dev->set_channel(std::move(rpc)); |
| |
| // If we have bus device args we are, by definition, a bus device. |
| if (dev->args_.size() > 0) { |
| dev->flags |= DEV_CTX_MUST_ISOLATE; |
| } |
| |
| // We exist within our parent's device host |
| dev->set_host(parent->host()); |
| |
| // We must mark the device as invisible before publishing so |
| // that we don't send "device added" notifications. |
| if (invisible) { |
| dev->flags |= DEV_CTX_INVISIBLE; |
| } |
| |
| if ((status = devfs_publish(real_parent, dev)) < 0) { |
| return status; |
| } |
| |
| if ((status = Device::BeginWait(dev, coordinator->dispatcher())) != ZX_OK) { |
| return status; |
| } |
| |
| if (dev->host_) { |
| // TODO host == nullptr should be impossible |
| dev->host_->devices().push_back(dev.get()); |
| } |
| real_parent->children_.push_back(dev.get()); |
| log(DEVLC, "devcoord: dev %p name='%s' (child)\n", real_parent.get(), |
| real_parent->name().data()); |
| |
| *device = std::move(dev); |
| return ZX_OK; |
| } |
| |
| zx_status_t Device::CreateComposite(Coordinator* coordinator, Devhost* devhost, |
| const CompositeDevice& composite, zx::channel rpc, |
| fbl::RefPtr<Device>* device) { |
| const auto& composite_props = composite.properties(); |
| fbl::Array<zx_device_prop_t> props(new zx_device_prop_t[composite_props.size()], |
| composite_props.size()); |
| memcpy(props.get(), composite_props.get(), props.size() * sizeof(props[0])); |
| |
| auto dev = fbl::MakeRefCounted<Device>(coordinator, composite.name(), fbl::String(), |
| fbl::String(), nullptr, ZX_PROTOCOL_COMPOSITE, |
| zx::channel()); |
| if (!dev) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| zx_status_t status = dev->SetProps(std::move(props)); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| dev->set_channel(std::move(rpc)); |
| // We exist within our parent's device host |
| dev->set_host(devhost); |
| |
| // TODO: Record composite membership |
| |
| // TODO(teisenbe): Figure out how to manifest in devfs? For now just hang it off of |
| // the root device? |
| if ((status = devfs_publish(coordinator->root_device(), dev)) < 0) { |
| return status; |
| } |
| |
| if ((status = Device::BeginWait(dev, coordinator->dispatcher())) != ZX_OK) { |
| return status; |
| } |
| |
| dev->host_->AddRef(); |
| dev->host_->devices().push_back(dev.get()); |
| |
| log(DEVLC, "devcoordinator: composite dev created %p name='%s'\n", dev.get(), |
| dev->name().data()); |
| |
| *device = std::move(dev); |
| return ZX_OK; |
| } |
| |
| zx_status_t Device::CreateProxy() { |
| ZX_ASSERT(proxy_ == nullptr); |
| |
| fbl::String driver_path = libname_; |
| // non-immortal devices, use foo.proxy.so for |
| // their proxy devices instead of foo.so |
| if (!(this->flags & DEV_CTX_IMMORTAL)) { |
| const char* begin = driver_path.data(); |
| const char* end = strstr(begin, ".so"); |
| fbl::StringPiece prefix(begin, end == nullptr ? driver_path.size() : end - begin); |
| fbl::AllocChecker ac; |
| driver_path = fbl::String::Concat({prefix, ".proxy.so"}, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| } |
| |
| auto dev = fbl::MakeRefCounted<Device>(this->coordinator, name_, std::move(driver_path), |
| fbl::String(), fbl::WrapRefPtr(this), protocol_id_, |
| zx::channel()); |
| if (dev == nullptr) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| dev->flags = DEV_CTX_PROXY; |
| proxy_ = std::move(dev); |
| log(DEVLC, "devcoord: dev %p name='%s' (proxy)\n", this, name_.data()); |
| return ZX_OK; |
| } |
| |
| void Device::DetachFromParent() { |
| if (this->flags & DEV_CTX_PROXY) { |
| parent_->proxy_ = nullptr; |
| } else { |
| parent_->children_.erase(*this); |
| } |
| parent_ = nullptr; |
| } |
| |
| zx_status_t Device::SignalReadyForBind(zx::duration delay) { |
| return publish_task_.PostDelayed(this->coordinator->dispatcher(), delay); |
| } |
| |
| fbl::RefPtr<SuspendTask> Device::RequestSuspendTask(uint32_t suspend_flags) { |
| if (active_suspend_) { |
| // We don't support different types of suspends concurrently, and |
| // shouldn't be able to reach this state. |
| ZX_ASSERT(suspend_flags == active_suspend_->suspend_flags()); |
| } else { |
| active_suspend_ = SuspendTask::Create(fbl::WrapRefPtr(this), suspend_flags); |
| } |
| return active_suspend_; |
| } |
| |
| zx_status_t Device::SendSuspend(uint32_t flags, SuspendCompletion completion) { |
| if (suspend_completion_) { |
| // We already have a pending suspend |
| return ZX_ERR_UNAVAILABLE; |
| } |
| log(DEVLC, "devcoordinator: suspend dev %p name='%s'\n", this, name_.data()); |
| zx_status_t status = dh_send_suspend(this, flags); |
| if (status != ZX_OK) { |
| return status; |
| } |
| suspend_completion_ = std::move(completion); |
| return ZX_OK; |
| } |
| |
| void Device::CompleteSuspend(zx_status_t status) { |
| if (status == ZX_OK) { |
| state_ = Device::State::kSuspended; |
| } |
| |
| active_suspend_ = nullptr; |
| SuspendCompletion completion(std::move(suspend_completion_)); |
| if (completion) { |
| completion(status); |
| } |
| } |
| |
| // Handle inbound messages from devhost to devices |
| void Device::HandleRpc(fbl::RefPtr<Device>&& dev, async_dispatcher_t* dispatcher, |
| async::WaitBase* wait, zx_status_t status, |
| const zx_packet_signal_t* signal) { |
| if (status != ZX_OK) { |
| log(ERROR, "devcoordinator: Device::HandleRpc aborting, saw status %d\n", status); |
| return; |
| } |
| |
| if (signal->observed & ZX_CHANNEL_READABLE) { |
| zx_status_t r; |
| if ((r = dev->HandleRead()) < 0) { |
| if (r != ZX_ERR_STOP) { |
| log(ERROR, "devcoordinator: device %p name='%s' rpc status: %d\n", dev.get(), |
| dev->name().data(), r); |
| } |
| // If this device isn't already dead (removed), remove it. RemoveDevice() may |
| // have been called by the RPC handler, in particular for the RemoveDevice RPC. |
| if ((dev->flags & DEV_CTX_DEAD) == 0) { |
| dev->coordinator->RemoveDevice(dev, true); |
| } |
| // Do not start waiting again on this device's channel again |
| return; |
| } |
| Device::BeginWait(std::move(dev), dispatcher); |
| return; |
| } |
| if (signal->observed & ZX_CHANNEL_PEER_CLOSED) { |
| log(ERROR, "devcoordinator: device %p name='%s' disconnected!\n", dev.get(), |
| dev->name().data()); |
| dev->coordinator->RemoveDevice(dev, true); |
| // Do not start waiting again on this device's channel again |
| return; |
| } |
| log(ERROR, "devcoordinator: no work? %08x\n", signal->observed); |
| Device::BeginWait(std::move(dev), dispatcher); |
| } |
| |
| static zx_status_t fidl_AddDevice(void* ctx, zx_handle_t raw_rpc, const uint64_t* props_data, |
| size_t props_count, const char* name_data, size_t name_size, |
| uint32_t protocol_id, const char* driver_path_data, |
| size_t driver_path_size, const char* args_data, size_t args_size, |
| zx_handle_t raw_client_remote, fidl_txn_t* txn); |
| static zx_status_t fidl_AddDeviceInvisible(void* ctx, zx_handle_t raw_rpc, |
| const uint64_t* props_data, size_t props_count, |
| const char* name_data, size_t name_size, |
| uint32_t protocol_id, const char* driver_path_data, |
| size_t driver_path_size, const char* args_data, |
| size_t args_size, zx_handle_t raw_client_remote, |
| fidl_txn_t* txn); |
| static zx_status_t fidl_RemoveDevice(void* ctx, fidl_txn_t* txn); |
| static zx_status_t fidl_MakeVisible(void* ctx, fidl_txn_t* txn); |
| static zx_status_t fidl_BindDevice(void* ctx, const char* driver_path_data, size_t driver_path_size, |
| fidl_txn_t* txn); |
| static zx_status_t fidl_RunCompatibilityTests(void* ctx, fidl_txn_t* txn); |
| static zx_status_t fidl_GetTopologicalPath(void* ctx, fidl_txn_t* txn); |
| static zx_status_t fidl_LoadFirmware(void* ctx, const char* fw_path_data, size_t fw_path_size, |
| fidl_txn_t* txn); |
| static zx_status_t fidl_GetMetadata(void* ctx, uint32_t key, fidl_txn_t* txn); |
| static zx_status_t fidl_GetMetadataSize(void* ctx, uint32_t key, fidl_txn_t* txn); |
| static zx_status_t fidl_AddMetadata(void* ctx, uint32_t key, const uint8_t* data_data, |
| size_t data_count, fidl_txn_t* txn); |
| static zx_status_t fidl_PublishMetadata(void* ctx, const char* device_path_data, |
| size_t device_path_size, uint32_t key, |
| const uint8_t* data_data, size_t data_count, |
| fidl_txn_t* txn); |
| static zx_status_t fidl_AddCompositeDevice( |
| void* ctx, const char* name_data, size_t name_size, const uint64_t* props_data, |
| size_t props_count, const fuchsia_device_manager_DeviceComponent components[16], |
| uint32_t components_count, uint32_t coresident_device_index, fidl_txn_t* txn); |
| |
| static const fuchsia_device_manager_Coordinator_ops_t fidl_ops = { |
| .AddDevice = fidl_AddDevice, |
| .AddDeviceInvisible = fidl_AddDeviceInvisible, |
| .RemoveDevice = fidl_RemoveDevice, |
| .MakeVisible = fidl_MakeVisible, |
| .BindDevice = fidl_BindDevice, |
| .GetTopologicalPath = fidl_GetTopologicalPath, |
| .LoadFirmware = fidl_LoadFirmware, |
| .GetMetadata = fidl_GetMetadata, |
| .GetMetadataSize = fidl_GetMetadataSize, |
| .AddMetadata = fidl_AddMetadata, |
| .PublishMetadata = fidl_PublishMetadata, |
| .AddCompositeDevice = fidl_AddCompositeDevice, |
| |
| .DmMexec = fidl_DmMexec, |
| .DirectoryWatch = fidl_DirectoryWatch, |
| .RunCompatibilityTests = fidl_RunCompatibilityTests, |
| }; |
| |
| zx_status_t Device::HandleRead() { |
| uint8_t msg[ZX_CHANNEL_MAX_MSG_BYTES]; |
| zx_handle_t hin[ZX_CHANNEL_MAX_MSG_HANDLES]; |
| uint32_t msize = sizeof(msg); |
| uint32_t hcount = fbl::count_of(hin); |
| |
| if (this->flags & DEV_CTX_DEAD) { |
| log(ERROR, "devcoordinator: dev %p already dead (in read)\n", this); |
| return ZX_ERR_INTERNAL; |
| } |
| |
| zx_status_t r; |
| if ((r = channel()->read(0, &msg, hin, msize, hcount, &msize, &hcount)) != ZX_OK) { |
| return r; |
| } |
| |
| fidl_msg_t fidl_msg = { |
| .bytes = msg, |
| .handles = hin, |
| .num_bytes = msize, |
| .num_handles = hcount, |
| }; |
| |
| if (fidl_msg.num_bytes < sizeof(fidl_message_header_t)) { |
| zx_handle_close_many(fidl_msg.handles, fidl_msg.num_handles); |
| return ZX_ERR_IO; |
| } |
| |
| auto hdr = static_cast<fidl_message_header_t*>(fidl_msg.bytes); |
| // Check if we're receiving a Coordinator request |
| { |
| FidlTxn txn(*channel(), hdr->txid); |
| r = fuchsia_device_manager_Coordinator_try_dispatch(this, txn.fidl_txn(), &fidl_msg, |
| &fidl_ops); |
| if (r != ZX_ERR_NOT_SUPPORTED) { |
| return r; |
| } |
| } |
| |
| // TODO: Check txid on the message |
| // This is an if statement because, depending on the state of the ordinal |
| // migration, GenOrdinal and Ordinal may be the same value. See FIDL-524. |
| uint32_t ordinal = hdr->ordinal; |
| if (ordinal == fuchsia_device_manager_DeviceControllerBindDriverOrdinal || |
| ordinal == fuchsia_device_manager_DeviceControllerBindDriverGenOrdinal) { |
| const char* err_msg = nullptr; |
| r = fidl_decode_msg(&fuchsia_device_manager_DeviceControllerBindDriverResponseTable, |
| &fidl_msg, &err_msg); |
| if (r != ZX_OK) { |
| log(ERROR, "devcoordinator: rpc: bind-driver '%s' received malformed reply: %s\n", |
| name_.data(), err_msg); |
| return ZX_ERR_IO; |
| } |
| auto resp = |
| reinterpret_cast<fuchsia_device_manager_DeviceControllerBindDriverResponse*>( |
| fidl_msg.bytes); |
| if (resp->status != ZX_OK) { |
| log(ERROR, "devcoordinator: rpc: bind-driver '%s' status %d\n", name_.data(), |
| resp->status); |
| } else { |
| Device* real_parent; |
| if (flags & DEV_CTX_PROXY) { |
| real_parent = this->parent().get(); |
| } else { |
| real_parent = this; |
| } |
| |
| for (auto& child : real_parent->children()) { |
| char bootarg[256]; |
| const char* drivername = |
| this->coordinator->LibnameToDriver(child.libname().data())->name.data(); |
| snprintf(bootarg, sizeof(bootarg), "driver.%s.run-compatibility-tests", |
| drivername); |
| |
| //FOR TESTING PURPOSES |
| if (!strcmp(bootarg, "driver.aml_sd_emmc.run-compatibility-tests") |
| //if (this->coordinator->boot_args().GetBool(bootarg, false) |
| && (real_parent->test_state() == Device::TestStateMachine::kTestNotStarted)) { |
| real_parent->DriverCompatibiltyTest(drivername); |
| break; |
| } else if (real_parent->test_state() == Device::TestStateMachine::kTestBindSent) { |
| real_parent->test_event().signal(0, TEST_BIND_DONE_SIGNAL); |
| break; |
| } |
| } |
| } |
| // TODO: try next driver, clear BOUND flag |
| } else if (ordinal == fuchsia_device_manager_DeviceControllerSuspendOrdinal || |
| ordinal == fuchsia_device_manager_DeviceControllerSuspendGenOrdinal) { |
| const char* err_msg = nullptr; |
| r = fidl_decode_msg(&fuchsia_device_manager_DeviceControllerSuspendResponseTable, |
| &fidl_msg, &err_msg); |
| if (r != ZX_OK) { |
| log(ERROR, "devcoordinator: rpc: suspend '%s' received malformed reply: %s\n", |
| name_.data(), err_msg); |
| return ZX_ERR_IO; |
| } |
| auto resp = |
| reinterpret_cast<fuchsia_device_manager_DeviceControllerSuspendResponse*>( |
| fidl_msg.bytes); |
| if (resp->status != ZX_OK) { |
| log(ERROR, "devcoordinator: rpc: suspend '%s' status %d\n", name_.data(), |
| resp->status); |
| } |
| |
| if (!suspend_completion_) { |
| log(ERROR, "devcoordinator: rpc: unexpected suspend reply for '%s' status %d\n", |
| name_.data(), resp->status); |
| return ZX_ERR_IO; |
| } |
| log(DEVLC, "devcoordinator: suspended dev %p name='%s'\n", this, name_.data()); |
| CompleteSuspend(resp->status); |
| } else { |
| log(ERROR, "devcoordinator: rpc: dev '%s' received wrong unexpected reply %08x\n", |
| name_.data(), hdr->ordinal); |
| zx_handle_close_many(fidl_msg.handles, fidl_msg.num_handles); |
| return ZX_ERR_IO; |
| } |
| return ZX_OK; |
| } |
| |
| zx_status_t Device::SetProps(fbl::Array<const zx_device_prop_t> props) { |
| // This function should only be called once |
| ZX_DEBUG_ASSERT(props_.get() == nullptr); |
| |
| props_ = std::move(props); |
| topo_prop_ = nullptr; |
| |
| for (const auto prop : props_) { |
| if (prop.id >= BIND_TOPO_START && prop.id <= BIND_TOPO_END) { |
| if (topo_prop_ != nullptr) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| topo_prop_ = ∝ |
| } |
| } |
| return ZX_OK; |
| } |
| |
| void Device::set_host(Devhost* host) { |
| if (host_) { |
| this->coordinator->ReleaseDevhost(host_); |
| } |
| host_ = host; |
| local_id_ = 0; |
| if (host_) { |
| host_->AddRef(); |
| local_id_ = host_->new_device_id(); |
| } |
| } |
| |
| zx_status_t Device::DriverCompatibiltyTest(const char* drivername) { |
| thrd_t t; |
| set_test_driver_name(drivername); |
| if (test_state() != TestStateMachine::kTestNotStarted) { |
| return ZX_ERR_ALREADY_EXISTS; |
| } |
| auto cb = [](void* arg) -> int { |
| return reinterpret_cast<Device*>(arg)->RunCompatibilityTests(); |
| }; |
| int ret = thrd_create_with_name(&t, cb, this, "compatibility-tests-thread"); |
| if (ret != thrd_success) { |
| log(ERROR, |
| "Driver Compatibility test failed for %s: " |
| "Thread creation failed\n", test_driver_name()); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| thrd_detach(t); |
| return ZX_OK; |
| } |
| |
| int Device::RunCompatibilityTests() { |
| log(INFO, "%s: Running ddk compatibility test for driver %s \n", __func__, test_driver_name()); |
| |
| // Device should be bound for test to work |
| if (!(flags & DEV_CTX_BOUND) || children().is_empty()) { |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Parent Device not bound\n", |
| test_driver_name()); |
| return ZX_ERR_INTERNAL; |
| } |
| zx_status_t status = zx::event::create(0, &test_event()); |
| if (status != ZX_OK) { |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Event creation failed : %d\n", |
| test_driver_name(), status); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| auto cleanup = fbl::MakeAutoCall([this]() { |
| test_event().reset(); |
| set_test_state(Device::TestStateMachine::kTestDone); |
| }); |
| |
| // Issue unbind on all its children. |
| for (auto& child : this->children()) { |
| status = dh_send_unbind(&child); |
| if (status != ZX_OK) { |
| // TODO(ravoorir): How do we return to clean state here? Forcefully |
| // remove all the children? |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Sending unbind to %s failed\n", |
| test_driver_name(), child.name().data()); |
| return ZX_ERR_INTERNAL; |
| } |
| } |
| |
| this->set_test_state(Device::TestStateMachine::kTestUnbindSent); |
| zx_signals_t observed = 0; |
| // Now wait for the device to be removed. |
| status = test_event().wait_one(TEST_REMOVE_DONE_SIGNAL, |
| zx::time(zx_deadline_after(ZX_SEC(20))), |
| &observed); |
| if (status != ZX_OK) { |
| if (status == ZX_ERR_TIMED_OUT) { |
| // The Remove did not complete. |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Timed out waiting for device to be removed. Check if device_remove was " |
| "called in the unbind routine of the driver: %d\n", |
| test_driver_name(), status); |
| } else { |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Error waiting for device to be removed.\n", |
| test_driver_name()); |
| } |
| return ZX_ERR_BAD_STATE; |
| } |
| this->set_test_state(Device::TestStateMachine::kTestRemoveCalled); |
| observed = 0; |
| this->coordinator->HandleNewDevice(fbl::WrapRefPtr(this)); |
| this->set_test_state(Device::TestStateMachine::kTestBindSent); |
| status = test_event().wait_one(TEST_BIND_DONE_SIGNAL, |
| zx::time(zx_deadline_after(ZX_SEC(20))), |
| &observed); |
| if (status != ZX_OK) { |
| if (status == ZX_ERR_TIMED_OUT) { |
| // The Bind did not complete. |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Timed out waiting for driver to be bound. Check if Bind routine " |
| "of the driver is doing blocking I/O: %d\n", |
| test_driver_name(), status); |
| } else { |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Error waiting for driver to be bound: %d\n", |
| test_driver_name(), status); |
| } |
| return ZX_ERR_BAD_STATE; |
| } |
| this->set_test_state(Device::TestStateMachine::kTestBindDone); |
| if (this->children().is_empty()) { |
| log(ERROR, |
| "devcoordinator: Driver Compatibility test failed for %s: " |
| "Driver Bind routine did not add a child. Check if Bind routine " |
| "Called DdkAdd() at the end.\n", test_driver_name()); |
| return -1; |
| } |
| |
| // TODO(ravoorir): Test Suspend and Resume hooks |
| log(ERROR, "%s: Driver Compatibility test %s for %s\n", __func__, |
| this->test_state() == Device::TestStateMachine::kTestBindDone ? "Succeeded" : "Failed", |
| test_driver_name()); |
| return ZX_OK; |
| } |
| |
| // Handlers for the messages from devices |
| static zx_status_t fidl_AddDevice(void* ctx, zx_handle_t raw_rpc, const uint64_t* props_data, |
| size_t props_count, const char* name_data, size_t name_size, |
| uint32_t protocol_id, const char* driver_path_data, |
| size_t driver_path_size, const char* args_data, size_t args_size, |
| zx_handle_t raw_client_remote, fidl_txn_t* txn) { |
| auto parent = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| zx::channel rpc(raw_rpc); |
| fbl::StringPiece name(name_data, name_size); |
| fbl::StringPiece driver_path(driver_path_data, driver_path_size); |
| fbl::StringPiece args(args_data, args_size); |
| zx::channel client_remote(raw_client_remote); |
| |
| fbl::RefPtr<Device> device; |
| zx_status_t status = parent->coordinator->AddDevice(parent, std::move(rpc), props_data, |
| props_count, name, protocol_id, driver_path, |
| args, false, std::move(client_remote), |
| &device); |
| // TODO(FLK-299): Remove this once the root cause is found. |
| if (parent->name() == "misc") { |
| printf("[%ld ms] (misc) AddDevice: %s\n", zx::clock::get_monotonic().get() / ZX_MSEC(1), |
| name.data()); |
| } else { |
| char path[fuchsia_device_manager_DEVICE_PATH_MAX + 1]; |
| zx_status_t topo_status = |
| parent->coordinator->GetTopologicalPath(device, path, sizeof(path)); |
| if (topo_status == ZX_OK && strstr(path, "misc/ramctl") != nullptr) { |
| printf("[%ld ms] (ramctl) AddDevice: %s\n", |
| zx::clock::get_monotonic().get() / ZX_MSEC(1), path); |
| } |
| } |
| uint64_t local_id = device != nullptr ? device->local_id() : 0; |
| return fuchsia_device_manager_CoordinatorAddDevice_reply(txn, status, local_id); |
| } |
| |
| static zx_status_t fidl_AddDeviceInvisible(void* ctx, zx_handle_t raw_rpc, |
| const uint64_t* props_data, size_t props_count, |
| const char* name_data, size_t name_size, |
| uint32_t protocol_id, const char* driver_path_data, |
| size_t driver_path_size, const char* args_data, |
| size_t args_size, zx_handle_t raw_client_remote, |
| fidl_txn_t* txn) { |
| auto parent = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| zx::channel rpc(raw_rpc); |
| fbl::StringPiece name(name_data, name_size); |
| fbl::StringPiece driver_path(driver_path_data, driver_path_size); |
| fbl::StringPiece args(args_data, args_size); |
| zx::channel client_remote(raw_client_remote); |
| |
| fbl::RefPtr<Device> device; |
| zx_status_t status = parent->coordinator->AddDevice(parent, std::move(rpc), props_data, |
| props_count, name, protocol_id, driver_path, |
| args, true, std::move(client_remote), |
| &device); |
| uint64_t local_id = device != nullptr ? device->local_id() : 0; |
| return fuchsia_device_manager_CoordinatorAddDeviceInvisible_reply(txn, status, local_id); |
| } |
| |
| static zx_status_t fidl_RemoveDevice(void* ctx, fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| if (dev->coordinator->InSuspend()) { |
| log(ERROR, "devcoordinator: rpc: remove-device '%s' forbidden in suspend\n", |
| dev->name().data()); |
| return fuchsia_device_manager_CoordinatorRemoveDevice_reply(txn, ZX_ERR_BAD_STATE); |
| } |
| |
| log(RPC_IN, "devcoordinator: rpc: remove-device '%s'\n", dev->name().data()); |
| // TODO(teisenbe): RemoveDevice and the reply func can return errors. We should probably |
| // act on it, but the existing code being migrated does not. |
| dev->coordinator->RemoveDevice(dev, false); |
| fuchsia_device_manager_CoordinatorRemoveDevice_reply(txn, ZX_OK); |
| |
| // Return STOP to signal we are done with this channel |
| return ZX_ERR_STOP; |
| } |
| |
| static zx_status_t fidl_MakeVisible(void* ctx, fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| if (dev->coordinator->InSuspend()) { |
| log(ERROR, "devcoordinator: rpc: make-visible '%s' forbidden in suspend\n", |
| dev->name().data()); |
| return fuchsia_device_manager_CoordinatorMakeVisible_reply(txn, ZX_ERR_BAD_STATE); |
| } |
| log(RPC_IN, "devcoordinator: rpc: make-visible '%s'\n", dev->name().data()); |
| // TODO(teisenbe): MakeVisibile can return errors. We should probably |
| // act on it, but the existing code being migrated does not. |
| dev->coordinator->MakeVisible(dev); |
| return fuchsia_device_manager_CoordinatorMakeVisible_reply(txn, ZX_OK); |
| } |
| |
| static zx_status_t fidl_BindDevice(void* ctx, const char* driver_path_data, size_t driver_path_size, |
| fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| fbl::StringPiece driver_path(driver_path_data, driver_path_size); |
| if (dev->coordinator->InSuspend()) { |
| log(ERROR, "devcoordinator: rpc: bind-device '%s' forbidden in suspend\n", dev->name().data()); |
| return fuchsia_device_manager_CoordinatorBindDevice_reply(txn, ZX_ERR_BAD_STATE); |
| } |
| // Made this log at ERROR instead of RPC_IN to help debug DNO-492; we should |
| // take it back down when done with that bug. |
| log(ERROR, "devcoordinator: rpc: bind-device '%s'\n", dev->name().data()); |
| zx_status_t status = dev->coordinator->BindDevice(dev, driver_path, false /* new device */); |
| return fuchsia_device_manager_CoordinatorBindDevice_reply(txn, status); |
| } |
| |
| static zx_status_t fidl_RunCompatibilityTests(void* ctx, fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| //zx_status_t status = dev->coordinator->DriverCompatibiltyTest(dev); |
| return fuchsia_device_manager_CoordinatorRunCompatibilityTests_reply(txn, ZX_OK); |
| } |
| |
| static zx_status_t fidl_GetTopologicalPath(void* ctx, fidl_txn_t* txn) { |
| char path[fuchsia_device_manager_DEVICE_PATH_MAX + 1]; |
| |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| zx_status_t status; |
| if ((status = dev->coordinator->GetTopologicalPath(dev, path, sizeof(path))) != ZX_OK) { |
| return fuchsia_device_manager_CoordinatorGetTopologicalPath_reply(txn, status, nullptr, 0); |
| } |
| return fuchsia_device_manager_CoordinatorGetTopologicalPath_reply(txn, ZX_OK, path, |
| strlen(path)); |
| } |
| |
| static zx_status_t fidl_LoadFirmware(void* ctx, const char* fw_path_data, size_t fw_path_size, |
| fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| |
| char fw_path[fuchsia_device_manager_DEVICE_PATH_MAX + 1]; |
| memcpy(fw_path, fw_path_data, fw_path_size); |
| fw_path[fw_path_size] = 0; |
| |
| zx::vmo vmo; |
| uint64_t size = 0; |
| zx_status_t status; |
| if ((status = dev->coordinator->LoadFirmware(dev, fw_path, &vmo, &size)) != ZX_OK) { |
| return fuchsia_device_manager_CoordinatorLoadFirmware_reply(txn, status, ZX_HANDLE_INVALID, |
| 0); |
| } |
| |
| return fuchsia_device_manager_CoordinatorLoadFirmware_reply(txn, ZX_OK, vmo.release(), size); |
| } |
| |
| static zx_status_t fidl_GetMetadata(void* ctx, uint32_t key, fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| |
| uint8_t data[fuchsia_device_manager_METADATA_MAX]; |
| size_t actual = 0; |
| zx_status_t status = dev->coordinator->GetMetadata(dev, key, data, sizeof(data), &actual); |
| if (status != ZX_OK) { |
| return fuchsia_device_manager_CoordinatorGetMetadata_reply(txn, status, nullptr, 0); |
| } |
| return fuchsia_device_manager_CoordinatorGetMetadata_reply(txn, status, data, actual); |
| } |
| |
| static zx_status_t fidl_GetMetadataSize(void* ctx, uint32_t key, fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| size_t size; |
| zx_status_t status = dev->coordinator->GetMetadataSize(dev, key, &size); |
| if (status != ZX_OK) { |
| return fuchsia_device_manager_CoordinatorGetMetadataSize_reply(txn, status, 0); |
| } |
| return fuchsia_device_manager_CoordinatorGetMetadataSize_reply(txn, status, size); |
| } |
| |
| static zx_status_t fidl_AddMetadata(void* ctx, uint32_t key, const uint8_t* data_data, |
| size_t data_count, fidl_txn_t* txn) { |
| static_assert(fuchsia_device_manager_METADATA_MAX <= UINT32_MAX); |
| |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| zx_status_t status = |
| dev->coordinator->AddMetadata(dev, key, data_data, static_cast<uint32_t>(data_count)); |
| return fuchsia_device_manager_CoordinatorAddMetadata_reply(txn, status); |
| } |
| |
| static zx_status_t fidl_PublishMetadata(void* ctx, const char* device_path_data, |
| size_t device_path_size, uint32_t key, |
| const uint8_t* data_data, size_t data_count, |
| fidl_txn_t* txn) { |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| |
| char path[fuchsia_device_manager_DEVICE_PATH_MAX + 1]; |
| memcpy(path, device_path_data, device_path_size); |
| path[device_path_size] = 0; |
| |
| zx_status_t status = dev->coordinator->PublishMetadata(dev, path, key, data_data, |
| static_cast<uint32_t>(data_count)); |
| return fuchsia_device_manager_CoordinatorPublishMetadata_reply(txn, status); |
| } |
| |
| static zx_status_t fidl_AddCompositeDevice( |
| void* ctx, const char* name_data, size_t name_size, const uint64_t* props_data, |
| size_t props_count, const fuchsia_device_manager_DeviceComponent components[16], |
| uint32_t components_count, uint32_t coresident_device_index, fidl_txn_t* txn) { |
| |
| auto dev = fbl::WrapRefPtr(static_cast<Device*>(ctx)); |
| |
| fbl::StringPiece name(name_data, name_size); |
| auto props = reinterpret_cast<const zx_device_prop_t*>(props_data); |
| |
| zx_status_t status = dev->coordinator->AddCompositeDevice(dev, name, props, props_count, |
| components, components_count, |
| coresident_device_index); |
| return fuchsia_device_manager_CoordinatorAddCompositeDevice_reply(txn, status); |
| } |
| |
| } // namespace devmgr |
