| // 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_controller_connection.h" |
| |
| #include <fidl/fuchsia.device/cpp/wire.h> |
| #include <lib/zx/channel.h> |
| #include <lib/zx/vmo.h> |
| #include <zircon/status.h> |
| |
| #include <fbl/auto_lock.h> |
| #include <fbl/string_printf.h> |
| |
| #include "driver_host.h" |
| #include "env.h" |
| #include "log.h" |
| #include "proxy_iostate.h" |
| #include "zx_device.h" |
| #include "zx_driver.h" |
| |
| namespace { |
| |
| // Handles outstanding calls to fuchsia.device.manager.DeviceController/BindDriver |
| // and fuchsia.device.Controller/Bind. |
| void BindReply(const fbl::RefPtr<zx_device_t>& dev, |
| DeviceControllerConnection::BindDriverCompleter::Sync& completer, zx_status_t status, |
| zx::channel test_output = zx::channel()) { |
| completer.Reply(status, std::move(test_output)); |
| |
| bool complete_bind = true; |
| for (auto& child : dev->children()) { |
| if ((child.flags() & DEV_FLAG_INVISIBLE) || child.ops()->init) { |
| // Driver has initialization to do. |
| complete_bind = false; |
| } |
| } |
| if (!complete_bind) { |
| dev->set_complete_bind_rebind_after_init(true); |
| return; |
| } |
| if (auto bind_conn = dev->take_bind_conn(); bind_conn) { |
| bind_conn(status); |
| } |
| |
| if (auto rebind_conn = dev->take_rebind_conn(); rebind_conn) { |
| rebind_conn(status); |
| } |
| } |
| |
| } // namespace |
| |
| void DeviceControllerConnection::Init(InitRequestView request, InitCompleter::Sync& completer) { |
| ZX_ASSERT(this->dev()->init_cb == nullptr); |
| |
| auto trace = this->dev()->BeginAsyncTrace("driver_host:lifecycle", "init"); |
| this->dev()->init_cb = [completer = completer.ToAsync(), trace = std::move(trace)]( |
| zx_status_t status) mutable { completer.Reply(status); }; |
| fbl::AutoLock lock(&driver_host_context_->api_lock()); |
| driver_host_context_->DeviceInit(this->dev()); |
| } |
| |
| void DeviceControllerConnection::Suspend(SuspendRequestView request, |
| SuspendCompleter::Sync& completer) { |
| ZX_ASSERT(this->dev()->suspend_cb == nullptr); |
| |
| auto trace = this->dev()->BeginAsyncTrace("driver_host:lifecycle", "suspend"); |
| this->dev()->suspend_cb = [completer = completer.ToAsync(), trace = std::move(trace)]( |
| zx_status_t status, uint8_t out_state) mutable { |
| if (status == ZX_ERR_NOT_SUPPORTED) { |
| status = ZX_OK; |
| } |
| completer.Reply(status); |
| }; |
| fbl::AutoLock lock(&driver_host_context_->api_lock()); |
| driver_host_context_->DeviceSystemSuspend(this->dev(), request->flags); |
| } |
| |
| void DeviceControllerConnection::Resume(ResumeRequestView request, |
| ResumeCompleter::Sync& completer) { |
| ZX_ASSERT(this->dev()->resume_cb == nullptr); |
| |
| auto trace = this->dev()->BeginAsyncTrace("driver_host:lifecycle", "resume"); |
| this->dev()->resume_cb = [completer = completer.ToAsync(), trace = std::move(trace)]( |
| zx_status_t status, uint8_t out_power_state, |
| uint32_t out_perf_state) mutable { |
| if (status == ZX_ERR_NOT_SUPPORTED) { |
| status = ZX_OK; |
| } |
| if (status != ZX_OK && |
| (out_power_state == |
| static_cast<uint8_t>(fuchsia_device::wire::DevicePowerState::kDevicePowerStateD0))) { |
| // Do not fail system resume, when the device is unable to go into a particular performance |
| // state, but resumed to a working state. |
| status = ZX_OK; |
| } |
| completer.Reply(status); |
| }; |
| fbl::AutoLock lock(&driver_host_context_->api_lock()); |
| driver_host_context_->DeviceSystemResume(this->dev(), request->target_system_state); |
| } |
| |
| void DeviceControllerConnection::ConnectProxy(ConnectProxyRequestView request, |
| ConnectProxyCompleter::Sync& _completer) { |
| VLOGD(1, *dev(), "Connected to proxy for device %p", dev().get()); |
| dev()->ops()->rxrpc(dev()->ctx, ZX_HANDLE_INVALID); |
| // Ignore any errors in the creation for now? |
| // TODO(teisenbe): Investigate if this is the right thing |
| ProxyIostate::Create(dev(), std::move(request->shadow), |
| driver_host_context_->loop().dispatcher()); |
| } |
| |
| void DeviceControllerConnection::BindDriver(BindDriverRequestView request, |
| BindDriverCompleter::Sync& completer) { |
| const auto& dev = this->dev(); |
| std::string_view driver_path(request->driver_path.data(), request->driver_path.size()); |
| |
| // TODO: api lock integration |
| if (driver_path != "/boot/driver/fragment.so") { |
| LOGD(INFO, *dev, "Binding driver '%.*s'", static_cast<int>(driver_path.size()), |
| driver_path.data()); |
| } else { |
| LOGD(TRACE, *dev, "Binding driver '%.*s'", static_cast<int>(driver_path.size()), |
| driver_path.data()); |
| } |
| if (dev->flags() & DEV_FLAG_DEAD) { |
| LOGD(ERROR, *dev, "Cannot bind to removed device"); |
| BindReply(dev, completer, ZX_ERR_IO_NOT_PRESENT); |
| return; |
| } |
| |
| fbl::RefPtr<zx_driver_t> drv; |
| fbl::RefPtr<Driver> driver; |
| zx_status_t r = |
| driver_host_context_->FindDriver(driver_path, std::move(request->driver), &drv, &driver); |
| if (r != ZX_OK) { |
| LOGD(ERROR, *dev, "Failed to load driver '%.*s': %s", static_cast<int>(driver_path.size()), |
| driver_path.data(), zx_status_get_string(r)); |
| BindReply(dev, completer, r); |
| return; |
| } |
| |
| // Check for driver test flags. |
| bool tests_default = getenv_bool("driver.tests.enable", false); |
| auto option = fbl::StringPrintf("driver.%s.tests.enable", drv->name()); |
| zx::channel test_output; |
| if (getenv_bool(option.data(), tests_default) && drv->has_run_unit_tests_op()) { |
| zx::channel test_input; |
| zx::channel::create(0, &test_input, &test_output); |
| bool tests_passed = drv->RunUnitTestsOp(dev, driver, std::move(test_input)); |
| if (!tests_passed) { |
| FX_LOGF(ERROR, "unit-tests", "[ FAILED ] %s", drv->name()); |
| drv->set_status(ZX_ERR_BAD_STATE); |
| BindReply(dev, completer, ZX_ERR_BAD_STATE, std::move(test_output)); |
| return; |
| } |
| FX_LOGF(INFO, "unit-tests", "[ PASSED ] %s", drv->name()); |
| } |
| |
| if (drv->has_bind_op()) { |
| internal::BindContext bind_ctx = { |
| .parent = dev, |
| .child = nullptr, |
| }; |
| r = drv->BindOp(&bind_ctx, driver, dev); |
| |
| if (r != ZX_OK) { |
| LOGD(ERROR, *dev, "Failed to bind driver '%.*s': %s", static_cast<int>(driver_path.size()), |
| driver_path.data(), zx_status_get_string(r)); |
| } else if (bind_ctx.child == nullptr) { |
| LOGD(WARNING, *dev, "Driver '%.*s' did not add a child device in bind()", |
| static_cast<int>(driver_path.size()), driver_path.data()); |
| } |
| BindReply(dev, completer, r, std::move(test_output)); |
| return; |
| } |
| |
| if (!drv->has_create_op()) { |
| LOGD(ERROR, *dev, "Neither create() nor bind() are implemented for driver '%.*s'", |
| static_cast<int>(driver_path.size()), driver_path.data()); |
| } |
| BindReply(dev, completer, ZX_ERR_NOT_SUPPORTED, std::move(test_output)); |
| } |
| |
| void DeviceControllerConnection::Unbind(UnbindRequestView request, |
| UnbindCompleter::Sync& completer) { |
| ZX_ASSERT(this->dev()->unbind_cb == nullptr); |
| |
| auto trace = this->dev()->BeginAsyncTrace("driver_host:lifecycle", "unbind"); |
| |
| this->dev()->unbind_cb = [dev = this->dev(), completer = completer.ToAsync(), |
| trace = std::move(trace)](zx_status_t status) mutable { |
| if (status != ZX_OK && dev->parent()) { |
| // If unbind returns an error, and if client is waiting for unbind to complete, |
| // inform the client. |
| if (auto unbind_children_conn = dev->parent()->take_unbind_children_conn(); |
| unbind_children_conn) { |
| unbind_children_conn(status); |
| } |
| } |
| completer.ReplySuccess(); |
| }; |
| fbl::AutoLock lock(&driver_host_context_->api_lock()); |
| driver_host_context_->DeviceUnbind(this->dev()); |
| } |
| |
| void DeviceControllerConnection::CompleteRemoval(CompleteRemovalRequestView request, |
| CompleteRemovalCompleter::Sync& completer) { |
| ZX_ASSERT(this->dev()->removal_cb == nullptr); |
| this->dev()->removal_cb = [completer = completer.ToAsync()](zx_status_t status) mutable { |
| completer.ReplySuccess(); |
| }; |
| fbl::AutoLock lock(&driver_host_context_->api_lock()); |
| driver_host_context_->DeviceCompleteRemoval(this->dev()); |
| } |
| |
| DeviceControllerConnection::DeviceControllerConnection( |
| DriverHostContext* ctx, fbl::RefPtr<zx_device> dev, |
| fidl::WireSharedClient<fuchsia_device_manager::Coordinator> coordinator_client) |
| : driver_host_context_(ctx), |
| dev_(std::move(dev)), |
| coordinator_client_(std::move(coordinator_client)) { |
| dev_->coordinator_client = coordinator_client_.Clone(); |
| } |
| |
| std::unique_ptr<DeviceControllerConnection> DeviceControllerConnection::Create( |
| DriverHostContext* ctx, fbl::RefPtr<zx_device> dev, |
| fidl::WireSharedClient<fuchsia_device_manager::Coordinator> coordinator_client) { |
| return std::make_unique<DeviceControllerConnection>(ctx, std::move(dev), |
| std::move(coordinator_client)); |
| } |
| |
| void DeviceControllerConnection::Bind( |
| std::unique_ptr<DeviceControllerConnection> conn, |
| fidl::ServerEnd<fuchsia_device_manager::DeviceController> request, |
| async_dispatcher_t* dispatcher) { |
| auto dev = conn->dev_; |
| fbl::AutoLock al(&dev->controller_lock); |
| dev->controller_binding = fidl::BindServer( |
| dispatcher, std::move(request), std::move(conn), |
| [](DeviceControllerConnection* self, fidl::UnbindInfo info, |
| fidl::ServerEnd<fuchsia_device_manager::DeviceController> server_end) { |
| auto& dev = self->dev_; |
| if (info.is_user_initiated()) { |
| return; |
| } |
| if (info.is_peer_closed()) { |
| // Check if we were expecting this peer close. If not, this could be a |
| // serious bug. |
| { |
| fbl::AutoLock al(&dev->controller_lock); |
| if (!dev->controller_binding) { |
| // We're in the middle of shutting down, so just stop processing |
| // signals and wait for the queued shutdown packet. It has a |
| // reference to the connection, which it will use to recover |
| // ownership of it. |
| return; |
| } |
| } |
| |
| // This is expected in test environments where driver_manager has |
| // terminated. |
| // TODO(fxbug.dev/52627): Support graceful termination. |
| LOGD(WARNING, *dev, "driver_manager disconnected from device %p", dev.get()); |
| zx_process_exit(1); |
| return; |
| } |
| LOGD(FATAL, *dev, "FIDL error for device %p: %s", dev.get(), |
| info.FormatDescription().c_str()); |
| }); |
| } |
| |
| // Handler for when a fuchsia.io open() is called on a device |
| void DeviceControllerConnection::Open(OpenRequestView request, OpenCompleter::Sync& completer) { |
| VLOGD(1, *dev(), "Opening device %p", dev().get()); |
| if (request->path.size() > 1 && request->path.data()[0] != '.') { |
| LOGD(ERROR, *dev(), "Attempt to open path '%.*s'", static_cast<int>(request->path.size()), |
| request->path.data()); |
| } |
| driver_host_context_->DeviceConnect(this->dev(), request->flags, request->object.TakeChannel()); |
| } |
