| // Copyright 2020 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_CONNECTIVITY_NETWORK_DRIVERS_NETWORK_DEVICE_MAC_MAC_INTERFACE_H_ | |
| #define SRC_CONNECTIVITY_NETWORK_DRIVERS_NETWORK_DEVICE_MAC_MAC_INTERFACE_H_ | |
| #include <fidl/fuchsia.hardware.network.driver/cpp/driver/wire.h> | |
| #include <fidl/fuchsia.hardware.network.driver/cpp/fidl.h> | |
| #include <fidl/fuchsia.hardware.network/cpp/wire.h> | |
| #include <lib/async/cpp/task.h> | |
| #include <lib/async/dispatcher.h> | |
| #include <lib/fidl/cpp/wire/server.h> | |
| #include <memory> | |
| #include <unordered_set> | |
| #include <fbl/auto_lock.h> | |
| #include <fbl/intrusive_double_list.h> | |
| #include <fbl/intrusive_hash_table.h> | |
| #include <fbl/mutex.h> | |
| #include <fbl/ref_counted.h> | |
| #include <fbl/ref_ptr.h> | |
| #include "public/network_mac.h" | |
| namespace network { | |
| using MacAddress = fuchsia_net::wire::MacAddress; | |
| namespace netdev = fuchsia_hardware_network; | |
| namespace netdriver = fuchsia_hardware_network_driver; | |
| namespace internal { | |
| class MacClientInstance; | |
| class MacInterface : public ::network::MacAddrDeviceInterface, | |
| public std::enable_shared_from_this<MacInterface> { | |
| public: | |
| static void Create(fdf::ClientEnd<netdriver::MacAddr> parent, fdf_dispatcher_t* dispatcher, | |
| OnCreated&& on_created); | |
| ~MacInterface() override; | |
| // MacAddrDevice implementation: | |
| zx_status_t Bind(async_dispatcher_t* dispatcher, | |
| fidl::ServerEnd<netdev::MacAddressing> req) override; | |
| void Teardown(fit::callback<void()> callback) override; | |
| std::optional<netdev::wire::MacFilterMode> ConvertMode( | |
| const netdev::wire::MacFilterMode& mode) const; | |
| private: | |
| friend MacClientInstance; | |
| // Consolidates all the requested operating modes and multicast filtering from all the attached | |
| // clients into a final operating mode and sets it on the parent device implementation. | |
| void Consolidate(fit::function<void(zx_status_t)> callback) __TA_RELEASE(lock_); | |
| // Closes a client instance, causing a new operating mode to be calculated once the instance state | |
| // is removed. If the `MacInterface` is undergoing a teardown, the teardown will be finished if | |
| // there are no more open client instances. | |
| void CloseClient(MacClientInstance* client) __TA_EXCLUDES(lock_); | |
| // Called when `impl_` finishes tearing down the binding. | |
| void OnImplTeardown(); | |
| // Checks if all of the teardown conditions are complete, and calls | |
| // `teardown_callback_` if so. | |
| void MaybeFinishTeardown() __TA_RELEASE(lock_); | |
| void Init(fit::callback<void(zx_status_t)>&& on_complete); | |
| void GetFeatures(fit::callback<void(zx_status_t)>&& on_complete); | |
| void SetDefaultMode(fit::callback<void(zx_status_t)>&& on_complete); | |
| MacInterface() = default; | |
| fdf::WireSharedClient<netdriver::MacAddr> impl_; | |
| bool impl_torn_down_ __TA_GUARDED(lock_) = false; | |
| netdriver::Features features_; | |
| netdev::wire::MacFilterMode default_mode_; | |
| mutable fbl::Mutex lock_; | |
| fbl::DoublyLinkedList<std::unique_ptr<MacClientInstance>> clients_ __TA_GUARDED(lock_); | |
| fbl::DoublyLinkedList<std::unique_ptr<MacClientInstance>> dead_clients_ __TA_GUARDED(lock_); | |
| fit::callback<void()> teardown_callback_ __TA_GUARDED(lock_); | |
| }; | |
| // The state associated with a FIDL client for fuchsia.hardware.network.MacAddressing. | |
| class ClientState { | |
| public: | |
| // Helper class to store a Mac Address in an unordered_set. Hashing is performed by the | |
| // `MacHasher` class. | |
| struct Addr { | |
| MacAddress address; | |
| bool operator==(const Addr& a) const { | |
| return std::equal(address.octets.begin(), address.octets.end(), a.address.octets.begin(), | |
| a.address.octets.end()); | |
| } | |
| }; | |
| // Helper class to hash a Mac Address to store it in an unordered_set. | |
| class MacHasher { | |
| public: | |
| size_t operator()(const Addr& a) const { | |
| size_t hash = 0; | |
| size_t shift = 0; | |
| static_assert(decltype(a.address.octets)::size() <= sizeof(hash)); | |
| for (uint8_t octet : a.address.octets) { | |
| hash |= static_cast<size_t>(octet) << shift; | |
| shift += 8; | |
| } | |
| return hash; | |
| } | |
| }; | |
| explicit ClientState(fuchsia_hardware_network::wire::MacFilterMode filter_mode) | |
| : filter_mode(filter_mode) {} | |
| fuchsia_hardware_network::wire::MacFilterMode filter_mode; | |
| std::unordered_set<Addr, MacHasher> addresses; | |
| }; | |
| // An instance representing a FIDL client to the MacAddressing server. | |
| // | |
| // `MacClientInstance` keeps the state associated with the client and is responsible for fulfilling | |
| // FIDL requests. | |
| class MacClientInstance : public fidl::WireServer<netdev::MacAddressing>, | |
| public fbl::DoublyLinkedListable<std::unique_ptr<MacClientInstance>> { | |
| public: | |
| explicit MacClientInstance(MacInterface* parent, netdev::wire::MacFilterMode default_mode); | |
| void GetUnicastAddress(GetUnicastAddressCompleter::Sync& _completer) override; | |
| void SetMode(SetModeRequestView request, SetModeCompleter::Sync& _completer) override; | |
| void AddMulticastAddress(AddMulticastAddressRequestView request, | |
| AddMulticastAddressCompleter::Sync& _completer) override; | |
| void RemoveMulticastAddress(RemoveMulticastAddressRequestView request, | |
| RemoveMulticastAddressCompleter::Sync& _completer) override; | |
| // Binds the client instance to serve FIDL requests from the provided request channel. | |
| // All requests will be operated on the provided dispatcher. | |
| zx_status_t Bind(async_dispatcher_t* dispatcher, fidl::ServerEnd<netdev::MacAddressing> req); | |
| // Unbinds the client instance. | |
| // Once unbound it'll call `CloseClient` on its parent asynchronously. | |
| void Unbind(); | |
| // Accesses the client state. | |
| // Client state must only be accessed under the parent's MacInterface lock. | |
| const ClientState& state() const { return state_; } | |
| private: | |
| // Pointer to parent MacInterface, not owned. | |
| MacInterface* const parent_; | |
| ClientState state_ __TA_GUARDED(parent_->lock_); | |
| std::optional<fidl::ServerBindingRef<netdev::MacAddressing>> binding_; | |
| }; | |
| } // namespace internal | |
| } // namespace network | |
| #endif // SRC_CONNECTIVITY_NETWORK_DRIVERS_NETWORK_DEVICE_MAC_MAC_INTERFACE_H_ |