| // Copyright 2016 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. | |
| #ifndef SRC_DEVICES_BIN_DRIVER_MANAGER_DEVFS_DEVFS_H_ | |
| #define SRC_DEVICES_BIN_DRIVER_MANAGER_DEVFS_DEVFS_H_ | |
| #include <fidl/fuchsia.component.runner/cpp/fidl.h> | |
| #include <fidl/fuchsia.device.fs/cpp/wire.h> | |
| #include <fidl/fuchsia.device/cpp/wire.h> | |
| #include <fidl/fuchsia.io/cpp/wire.h> | |
| #include <lib/async/dispatcher.h> | |
| #include <lib/component/incoming/cpp/clone.h> | |
| #include <lib/component/outgoing/cpp/outgoing_directory.h> | |
| #include <random> | |
| #include <fbl/ref_ptr.h> | |
| #include <fbl/string.h> | |
| #include "src/devices/bin/driver_manager/component_owner.h" | |
| #include "src/storage/lib/vfs/cpp/pseudo_dir.h" | |
| #include "src/storage/lib/vfs/cpp/vnode.h" | |
| namespace driver_manager { | |
| class Devfs; | |
| class PseudoDir; | |
| class DevfsDevice; | |
| // PathServer acts as a contained TopologicalPath server, allowing clients | |
| // to connect and vending the topological path of the devnode. | |
| // Pathserver checks the variable kClassesThatAllowTopologicalPath when clients | |
| // attempt to bind to the service, and prohibits clients from connecting to drivers | |
| // whose class name is not in the allowlist. | |
| class PathServer : public fidl::WireServer<fuchsia_device_fs::TopologicalPath> { | |
| public: | |
| explicit PathServer(std::string path, async_dispatcher_t* dispatcher) | |
| : path_(path), dispatcher_(dispatcher) {} | |
| // TopologicalPath protocol: | |
| void GetTopologicalPath(GetTopologicalPathCompleter::Sync& completer) override { | |
| completer.ReplySuccess(fidl::StringView::FromExternal(GetPath())); | |
| } | |
| void Bind(zx::channel channel, const std::string& class_name); | |
| fidl::ProtocolHandler<fuchsia_device_fs::TopologicalPath> GetHandler() { | |
| return bindings_.CreateHandler(this, dispatcher_, fidl::kIgnoreBindingClosure); | |
| } | |
| std::string GetPath() { return path_; } | |
| private: | |
| std::string path_; | |
| async_dispatcher_t* dispatcher_; | |
| fidl::ServerBindingGroup<fuchsia_device_fs::TopologicalPath> bindings_; | |
| }; | |
| class Devnode { | |
| public: | |
| // This class represents a device in devfs. It is called "passthrough" because it sends | |
| // the channel and the connection type to a callback function. | |
| struct PassThrough { | |
| // The Device connect callback is for accessing the /dev/class/xxx protocol for the device | |
| using DeviceConnectCallback = fit::function<zx_status_t(zx::channel)>; | |
| // The controller callback is for accessing the fuchsia.device/Controller | |
| // interface associated with the device. | |
| using ControllerConnectCallback = | |
| fit::function<zx_status_t(fidl::ServerEnd<fuchsia_device::Controller>)>; | |
| // Create a Passthrough class. The client must make sure that any captures in the callback | |
| // live as long as the passthrough class (for this reason it's strongly recommended to use | |
| // owned captures). | |
| explicit PassThrough(DeviceConnectCallback device_callback, | |
| ControllerConnectCallback controller_callback) | |
| : device_connect(std::make_shared<DeviceConnectCallback>(std::move(device_callback))), | |
| controller_connect( | |
| std::make_shared<ControllerConnectCallback>(std::move(controller_callback))) {} | |
| std::shared_ptr<DeviceConnectCallback> device_connect; | |
| std::shared_ptr<ControllerConnectCallback> controller_connect; | |
| }; | |
| using Target = std::optional<PassThrough>; | |
| // Constructs a root node. | |
| explicit Devnode(Devfs& devfs); | |
| // `parent` must outlive `this`. | |
| Devnode(Devfs& devfs, PseudoDir& parent, Target target, fbl::String name, const std::string& path, | |
| const std::string& class_name = "none"); | |
| ~Devnode(); | |
| Devnode(const Devnode&) = delete; | |
| Devnode& operator=(const Devnode&) = delete; | |
| Devnode(Devnode&&) = delete; | |
| Devnode& operator=(Devnode&&) = delete; | |
| // Add a child to this Devnode. The child will be added to both the topological path and under the | |
| // given `class_name`. | |
| zx_status_t add_child(std::string_view name, std::optional<std::string_view> class_name, | |
| Target target, DevfsDevice& out_child); | |
| // Exports `target`. | |
| // | |
| // If `topological_path` is provided, then `target` will be exported at that path under `this`. | |
| // | |
| // If `class_path` is provided, then `target` will be exported under that class path. | |
| zx_status_t export_dir(Devnode::Target target, std::optional<std::string_view> topological_path, | |
| std::optional<std::string_view> class_path, | |
| std::vector<std::unique_ptr<Devnode>>& out); | |
| std::string_view name() const; | |
| PseudoDir& children() const { return node().children(); } | |
| void advertise_modified(); | |
| // Publishes the node to devfs. Asserts if called more than once. | |
| void publish(); | |
| // The actual vnode implementation. This is distinct from the outer class | |
| // because `fs::Vnode` imposes reference-counted semantics, and we want to | |
| // preserve owned semantics on the outer class. | |
| // | |
| // This is exposed for use in tests. | |
| class VnodeImpl : public fs::Vnode { | |
| public: | |
| fuchsia_io::NodeProtocolKinds GetProtocols() const final; | |
| zx::result<fs::VnodeAttributes> GetAttributes() const final; | |
| zx_status_t Lookup(std::string_view name, fbl::RefPtr<fs::Vnode>* out) final; | |
| zx_status_t WatchDir(fs::FuchsiaVfs* vfs, fuchsia_io::wire::WatchMask mask, uint32_t options, | |
| fidl::ServerEnd<fuchsia_io::DirectoryWatcher> watcher) final; | |
| zx_status_t Readdir(fs::VdirCookie* cookie, void* dirents, size_t len, | |
| size_t* out_actual) final; | |
| zx_status_t ConnectService(zx::channel channel) final; | |
| PseudoDir& children() const { return *children_; } | |
| Devnode& holder_; | |
| const Target target_; | |
| private: | |
| friend fbl::internal::MakeRefCountedHelper<VnodeImpl>; | |
| VnodeImpl(Devnode& holder, Target target); | |
| bool IsDirectory() const; | |
| fbl::RefPtr<PseudoDir> children_ = fbl::MakeRefCounted<PseudoDir>(); | |
| }; | |
| private: | |
| // Advertises a service that corresponds to the class name | |
| zx_status_t TryAddService(std::string_view class_name, Target target, | |
| std::string_view instance_name); | |
| zx_status_t export_class(Devnode::Target target, std::string_view class_path, | |
| std::vector<std::unique_ptr<Devnode>>& out); | |
| zx_status_t export_topological_path(Devnode::Target target, std::string_view topological_path, | |
| std::vector<std::unique_ptr<Devnode>>& out); | |
| VnodeImpl& node() const { return *node_; } | |
| const Target& target() const { return node_->target_; } | |
| friend class Devfs; | |
| friend class PseudoDir; | |
| Devfs& devfs_; | |
| fbl::RefPtr<PseudoDir> parent_; | |
| const fbl::RefPtr<VnodeImpl> node_; | |
| const std::optional<fbl::String> name_; | |
| PathServer path_server_; | |
| // If service_name_ is valid, it means that there is a service advertised, and should be removed | |
| // upon destruction of this devnode. | |
| std::optional<std::string> service_path_; | |
| std::optional<std::string> service_name_; | |
| }; | |
| class PseudoDir : public fs::PseudoDir { | |
| public: | |
| std::unordered_map<fbl::String, std::reference_wrapper<Devnode>, std::hash<std::string_view>> | |
| unpublished; | |
| }; | |
| class DevfsDevice { | |
| public: | |
| void advertise_modified(); | |
| void publish(); | |
| void unpublish(); | |
| std::optional<Devnode>& topological_node() { return topological_; } | |
| private: | |
| friend Devnode; | |
| std::unique_ptr<Devnode>& protocol_node() { return protocol_; } | |
| std::optional<Devnode> topological_; | |
| // TODO(https://fxbug.dev/42062564): These protocol nodes are currently always empty directories. | |
| // Change this to a pure `RemoteNode` that doesn't expose a directory. | |
| std::unique_ptr<Devnode> protocol_; | |
| }; | |
| // Manages the root functionality of devfs. | |
| // Also acts a a proxy driver. | |
| // Mounts as a boot driver and adversises services that are registered under | |
| // a recognized class name. See class_names.h for more info. | |
| class Devfs : public fidl::Server<fuchsia_component_runner::ComponentController>, | |
| public fidl::WireAsyncEventHandler<fuchsia_component::Controller>, | |
| public ComponentOwner { | |
| public: | |
| // `root` must outlive `this`. | |
| explicit Devfs(std::optional<Devnode>& root, async_dispatcher_t* dispatcher); | |
| zx::result<fidl::ClientEnd<fuchsia_io::Directory>> Connect(fs::FuchsiaVfs& vfs); | |
| zx::result<std::string> MakeInstanceName(std::string_view class_name); | |
| // ComponentOwner | |
| void SetController(fidl::ClientEnd<fuchsia_component::Controller> component_controller) override; | |
| void OnComponentStarted(const std::weak_ptr<BootupTracker>& bootup_tracker, | |
| const std::string& moniker, | |
| zx::result<StartedComponent> component) override; | |
| void RequestStartComponent(fuchsia_process::wire::HandleInfo startup_handle, | |
| const std::string& moniker, | |
| const std::weak_ptr<BootupTracker>& bootup_tracker) override; | |
| bool SkipInjectedOffers() const override { return true; } | |
| fbl::RefPtr<PseudoDir> get_class_entry(std::string_view class_name) { | |
| ZX_ASSERT(class_entries_.contains(std::string(class_name))); | |
| return class_entries_[std::string(class_name)]; | |
| } | |
| async_dispatcher_t* dispatcher() { return dispatcher_; } | |
| component::OutgoingDirectory& outgoing() { return outgoing_; } | |
| // Called by the Driver Runner when the special devfs driver component is | |
| // created. | |
| void AttachComponent(fuchsia_component_runner::ComponentStartInfo info, | |
| fidl::ServerEnd<fuchsia_component_runner::ComponentController> controller); | |
| // fuchsia_component_runner::ComponentController | |
| void Stop(StopCompleter::Sync& completer) override { CloseComponent(); } | |
| void Kill(KillCompleter::Sync& completer) override { CloseComponent(); } | |
| void handle_unknown_method( | |
| fidl::UnknownMethodMetadata<fuchsia_component_runner::ComponentController> metadata, | |
| fidl::UnknownMethodCompleter::Sync& completer) override {} | |
| // fidl::WireAsyncEventHandler<fuchsia_component::Controller> | |
| void on_fidl_error(fidl::UnbindInfo info) override; | |
| void handle_unknown_event( | |
| fidl::UnknownEventMetadata<fuchsia_component::Controller> metadata) override {} | |
| private: | |
| friend class Devnode; | |
| static std::optional<std::reference_wrapper<fs::Vnode>> Lookup(PseudoDir& parent, | |
| std::string_view name); | |
| // close the fake driver component | |
| void CloseComponent(); | |
| Devnode& root_; | |
| component::OutgoingDirectory outgoing_; | |
| async_dispatcher_t* dispatcher_; | |
| std::optional<fidl::ServerBinding<fuchsia_component_runner::ComponentController>> binding_; | |
| fidl::WireClient<fuchsia_component::Controller> component_controller_; | |
| std::default_random_engine device_number_generator_; | |
| fbl::RefPtr<PseudoDir> class_ = fbl::MakeRefCounted<PseudoDir>(); | |
| std::unordered_map<std::string, fbl::RefPtr<PseudoDir>> class_entries_; | |
| }; | |
| } // namespace driver_manager | |
| #endif // SRC_DEVICES_BIN_DRIVER_MANAGER_DEVFS_DEVFS_H_ |