Merge changes from topic "stop-failing-my-presubmits" am: a2290b4825 am: 7999d8cb50 (83aabb8f) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@ filegroup {
		name: "BluetoothHciSources",
		srcs: [
		"acl_manager/acl_connection.cc",
		"acl_manager/acl_scheduler.cc",
		"acl_manager/classic_acl_connection.cc",
		"acl_manager/le_acl_connection.cc",
		"acl_manager/round_robin_scheduler.cc",
		@@ -37,6 +38,7 @@ filegroup {
		"acl_manager/classic_acl_connection_test.cc",
		"acl_builder_test.cc",
		"acl_manager_unittest.cc",
		"acl_manager/acl_scheduler_test.cc",
		"address_unittest.cc",
		"address_with_type_test.cc",
		"class_of_device_unittest.cc",

system/gd/hci/BUILD.gn

+1 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@ source_set("BluetoothHciSources") {
		sources = [
		"acl_manager.cc",
		"acl_manager/acl_connection.cc",
		"acl_manager/acl_scheduler.cc",
		"acl_manager/acl_fragmenter.cc",
		"acl_manager/classic_acl_connection.cc",
		"acl_manager/le_acl_connection.cc",

system/gd/hci/acl_manager.cc

+9 −2

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <set>

		#include "common/bidi_queue.h"
		#include "hci/acl_manager/acl_scheduler.h"
		#include "hci/acl_manager/classic_impl.h"
		#include "hci/acl_manager/connection_management_callbacks.h"
		#include "hci/acl_manager/le_acl_connection.h"
		@@ -52,6 +53,8 @@ using acl_manager::LeConnectionCallbacks;

		using acl_manager::RoundRobinScheduler;

		using acl_manager::AclScheduler;

		struct AclManager::impl {
		impl(const AclManager& acl_manager) : acl_manager_(acl_manager) {}

		@@ -60,6 +63,7 @@ struct AclManager::impl {
		handler_ = acl_manager_.GetHandler();
		controller_ = acl_manager_.GetDependency<Controller>();
		round_robin_scheduler_ = new RoundRobinScheduler(handler_, controller_, hci_layer_->GetAclQueueEnd());
		acl_scheduler_ = acl_manager_.GetDependency<AclScheduler>();

		hci_queue_end_ = hci_layer_->GetAclQueueEnd();
		hci_queue_end_->RegisterDequeue(
		@@ -67,8 +71,8 @@ struct AclManager::impl {
		bool crash_on_unknown_handle = false;
		{
		const std::lock_guard<std::mutex> lock(dumpsys_mutex_);
		classic_impl_ =
		new classic_impl(hci_layer_, controller_, handler_, round_robin_scheduler_, crash_on_unknown_handle);
		classic_impl_ = new classic_impl(
		hci_layer_, controller_, handler_, round_robin_scheduler_, crash_on_unknown_handle, acl_scheduler_);
		le_impl_ = new le_impl(hci_layer_, controller_, handler_, round_robin_scheduler_, crash_on_unknown_handle);
		}
		}
		@@ -90,6 +94,7 @@ struct AclManager::impl {
		hci_queue_end_ = nullptr;
		handler_ = nullptr;
		hci_layer_ = nullptr;
		acl_scheduler_ = nullptr;
		}

		// Invoked from some external Queue Reactable context 2
		@@ -118,6 +123,7 @@ struct AclManager::impl {

		classic_impl* classic_impl_ = nullptr;
		le_impl* le_impl_ = nullptr;
		AclScheduler* acl_scheduler_ = nullptr;
		os::Handler* handler_ = nullptr;
		Controller* controller_ = nullptr;
		HciLayer* hci_layer_ = nullptr;
		@@ -315,6 +321,7 @@ void AclManager::ListDependencies(ModuleList* list) const {
		list->add<HciLayer>();
		list->add<Controller>();
		list->add<storage::StorageModule>();
		list->add<AclScheduler>();
		}

		void AclManager::Start() {

system/gd/hci/acl_manager/acl_scheduler.cc

0 → 100644

+282 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "acl_scheduler.h"

		#include <optional>
		#include <queue>
		#include <unordered_set>
		#include <variant>

		namespace bluetooth {
		namespace hci {

		namespace acl_manager {

		struct AclCreateConnectionQueueEntry {
		Address address;
		common::ContextualOnceCallback<void()> callback;
		};

		struct RemoteNameRequestQueueEntry {
		Address address;
		common::ContextualOnceCallback<void()> callback;
		common::ContextualOnceCallback<void()> callback_when_cancelled;
		};

		using QueueEntry = std::variant<AclCreateConnectionQueueEntry, RemoteNameRequestQueueEntry>;

		struct AclScheduler::impl {
		void EnqueueOutgoingAclConnection(Address address, common::ContextualOnceCallback<void()> start_connection) {
		pending_outgoing_operations_.push_back(AclCreateConnectionQueueEntry{address, std::move(start_connection)});
		try_dequeue_next_operation();
		}

		void RegisterPendingIncomingConnection(Address address) {
		incoming_connecting_address_set_.insert(address);
		}

		void ReportAclConnectionCompletion(
		Address address,
		common::ContextualOnceCallback<void()> handle_outgoing_connection,
		common::ContextualOnceCallback<void()> handle_incoming_connection,
		common::ContextualOnceCallback<void(std::string)> handle_unknown_connection) {
		// Check if an outgoing request (a) exists, (b) is a Create Connection, (c) matches the received address
		if (outgoing_entry_.has_value()) {
		auto entry = std::get_if<AclCreateConnectionQueueEntry>(&outgoing_entry_.value());
		if (entry != nullptr && entry->address == address) {
		// If so, clear the current entry and advance the queue
		outgoing_entry_.reset();
		handle_outgoing_connection.InvokeIfNotEmpty();
		try_dequeue_next_operation();
		return;
		}
		}

		// Otherwise check if it's an incoming request and advance the queue if so
		if (incoming_connecting_address_set_.find(address) != incoming_connecting_address_set_.end()) {
		incoming_connecting_address_set_.erase(address);
		handle_incoming_connection.InvokeIfNotEmpty();
		} else {
		handle_unknown_connection.InvokeIfNotEmpty(set_of_incoming_connecting_addresses());
		}
		try_dequeue_next_operation();
		}

		void ReportOutgoingAclConnectionFailure() {
		if (!outgoing_entry_.has_value()) {
		LOG_ERROR("Outgoing connection failure reported, but none present!");
		return;
		}
		auto entry = std::get_if<AclCreateConnectionQueueEntry>(&outgoing_entry_.value());
		if (entry == nullptr) {
		LOG_ERROR("Outgoing connection failure reported, but we're currently doing an RNR!");
		return;
		}
		outgoing_entry_.reset();
		try_dequeue_next_operation();
		}

		void CancelAclConnection(
		Address address,
		common::ContextualOnceCallback<void()> cancel_connection,
		common::ContextualOnceCallback<void()> cancel_connection_completed) {
		auto ok = cancel_outgoing_or_queued_connection(
		[&](auto& entry) {
		auto entry_ptr = std::get_if<AclCreateConnectionQueueEntry>(&entry);
		return entry_ptr != nullptr && entry_ptr->address == address;
		},
		[&]() { cancel_connection.Invoke(); },
		[&](auto entry) { cancel_connection_completed.Invoke(); });
		if (!ok) {
		LOG_ERROR("Attempted to cancel connection to %s that does not exist", address.ToString().c_str());
		}
		}

		void EnqueueRemoteNameRequest(
		Address address,
		common::ContextualOnceCallback<void()> start_request,
		common::ContextualOnceCallback<void()> cancel_request_completed) {
		pending_outgoing_operations_.push_back(
		RemoteNameRequestQueueEntry{address, std::move(start_request), std::move(cancel_request_completed)});
		try_dequeue_next_operation();
		}

		void ReportRemoteNameRequestCompletion(Address address) {
		if (!outgoing_entry_.has_value()) {
		LOG_ERROR("Remote name request completion reported, but none taking place!");
		return;
		}

		std::visit(
		[](auto&& entry) {
		using T = std::decay_t<decltype(entry)>;
		if constexpr (std::is_same_v<T, RemoteNameRequestQueueEntry>) {
		LOG_INFO("Remote name request completed");
		} else if constexpr (std::is_same_v<T, AclCreateConnectionQueueEntry>) {
		LOG_ERROR(
		"Received RNR completion when ACL connection is outstanding - assuming the connection has failed and "
		"continuing");
		} else {
		static_assert(!sizeof(T*), "non-exhaustive visitor!");
		}
		},
		outgoing_entry_.value());

		outgoing_entry_.reset();
		try_dequeue_next_operation();
		}

		void CancelRemoteNameRequest(Address address, common::ContextualOnceCallback<void()> cancel_request) {
		auto ok = cancel_outgoing_or_queued_connection(
		[&](auto& entry) {
		auto entry_ptr = std::get_if<RemoteNameRequestQueueEntry>(&entry);
		return entry_ptr != nullptr && entry_ptr->address == address;
		},
		[&]() { cancel_request.Invoke(); },
		[](auto entry) { std::get<RemoteNameRequestQueueEntry>(entry).callback_when_cancelled.Invoke(); });
		if (!ok) {
		LOG_ERROR("Attempted to cancel remote name request to %s that does not exist", address.ToString().c_str());
		}
		};

		void Stop() {
		stopped_ = true;
		}

		private:
		void try_dequeue_next_operation() {
		if (stopped_) {
		return;
		}
		if (incoming_connecting_address_set_.empty() && !outgoing_entry_.has_value() &&
		!pending_outgoing_operations_.empty()) {
		LOG_INFO("Pending connections is not empty; so sending next connection");
		auto entry = std::move(pending_outgoing_operations_.front());
		pending_outgoing_operations_.pop_front();
		std::visit([](auto&& variant) { variant.callback.Invoke(); }, entry);
		outgoing_entry_ = std::move(entry);
		}
		}

		template <typename T, typename U, typename V>
		bool cancel_outgoing_or_queued_connection(T matcher, U cancel_outgoing, V cancelled_queued) {
		// Check if relevant connection is currently outgoing
		if (outgoing_entry_.has_value()) {
		if (matcher(outgoing_entry_.value())) {
		cancel_outgoing();
		return true;
		}
		}
		// Otherwise, clear from the queue
		auto it = std::find_if(pending_outgoing_operations_.begin(), pending_outgoing_operations_.end(), matcher);
		if (it == pending_outgoing_operations_.end()) {
		return false;
		}
		cancelled_queued(std::move(*it));
		pending_outgoing_operations_.erase(it);
		return true;
		}

		const std::string set_of_incoming_connecting_addresses() const {
		std::stringstream buffer;
		for (const auto& c : incoming_connecting_address_set_) buffer << " " << c;
		return buffer.str();
		}

		std::optional<QueueEntry> outgoing_entry_;
		std::deque<QueueEntry> pending_outgoing_operations_;
		std::unordered_set<Address> incoming_connecting_address_set_;
		bool stopped_ = false;
		};

		const ModuleFactory AclScheduler::Factory = ModuleFactory([]() { return new AclScheduler(); });

		AclScheduler::AclScheduler() : pimpl_(std::make_unique<impl>()){};
		AclScheduler::~AclScheduler() = default;

		void AclScheduler::EnqueueOutgoingAclConnection(
		Address address, common::ContextualOnceCallback<void()> start_connection) {
		GetHandler()->Call(
		&impl::EnqueueOutgoingAclConnection, common::Unretained(pimpl_.get()), address, std::move(start_connection));
		}

		void AclScheduler::RegisterPendingIncomingConnection(Address address) {
		GetHandler()->Call(&impl::RegisterPendingIncomingConnection, common::Unretained(pimpl_.get()), address);
		}

		void AclScheduler::ReportAclConnectionCompletion(
		Address address,
		common::ContextualOnceCallback<void()> handle_outgoing_connection,
		common::ContextualOnceCallback<void()> handle_incoming_connection,
		common::ContextualOnceCallback<void(std::string)> handle_unknown_connection) {
		GetHandler()->Call(
		&impl::ReportAclConnectionCompletion,
		common::Unretained(pimpl_.get()),
		address,
		std::move(handle_outgoing_connection),
		std::move(handle_incoming_connection),
		std::move(handle_unknown_connection));
		}

		void AclScheduler::ReportOutgoingAclConnectionFailure() {
		GetHandler()->Call(&impl::ReportOutgoingAclConnectionFailure, common::Unretained(pimpl_.get()));
		}

		void AclScheduler::CancelAclConnection(
		Address address,
		common::ContextualOnceCallback<void()> cancel_connection,
		common::ContextualOnceCallback<void()> cancel_connection_completed) {
		GetHandler()->Call(
		&impl::CancelAclConnection,
		common::Unretained(pimpl_.get()),
		address,
		std::move(cancel_connection),
		std::move(cancel_connection_completed));
		}

		void AclScheduler::EnqueueRemoteNameRequest(
		Address address,
		common::ContextualOnceCallback<void()> start_request,
		common::ContextualOnceCallback<void()> cancel_request_completed) {
		GetHandler()->Call(
		&impl::EnqueueRemoteNameRequest,
		common::Unretained(pimpl_.get()),
		address,
		std::move(start_request),
		std::move(cancel_request_completed));
		}

		void AclScheduler::ReportRemoteNameRequestCompletion(Address address) {
		GetHandler()->Call(&impl::ReportRemoteNameRequestCompletion, common::Unretained(pimpl_.get()), address);
		}

		void AclScheduler::CancelRemoteNameRequest(Address address, common::ContextualOnceCallback<void()> cancel_request) {
		GetHandler()->Call(
		&impl::CancelRemoteNameRequest, common::Unretained(pimpl_.get()), address, std::move(cancel_request));
		}

		void AclScheduler::ListDependencies(ModuleList* list) const {}

		void AclScheduler::Start() {}

		void AclScheduler::Stop() {
		pimpl_->Stop();
		}

		} // namespace acl_manager
		} // namespace hci
		} // namespace bluetooth
		No newline at end of file

system/gd/hci/acl_manager/acl_scheduler.h

0 → 100644

+101 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include <memory>
		#include <string>
		#include <utility>

		#include "common/contextual_callback.h"
		#include "hci/hci_packets.h"
		#include "module.h"

		namespace bluetooth {
		namespace hci {
		namespace acl_manager {

		// The AclScheduler is responsible for scheduling ACL connection-related operations (outgoing connections,
		// incoming connections, and remote name requests). It maintains a queue of operations initiated by us, and tracks
		// all incoming connections. We should never initiate a connection operation directly - instead, it should always
		// pass through this class, so that we can be sure that it does not conflict with other operations.
		//
		// However, it does not perform any actual HCI operations itself - it simply takes in callbacks, and executes them
		// at the appropriate time.
		class AclScheduler : public bluetooth::Module {
		public:
		// Schedule an ACL Create Connection request
		void EnqueueOutgoingAclConnection(Address address, common::ContextualOnceCallback<void()> start_connection);

		// Inform the scheduler that we are handling an incoming connection. This will block all future outgoing ACL
		// connection events until the incoming connection is deregistered.
		void RegisterPendingIncomingConnection(Address address);

		// Report that an ACL connection has completed, and dispatch to the appropriate callback based on the internal
		// state. Then, start the next operation.
		void ReportAclConnectionCompletion(
		Address address,
		common::ContextualOnceCallback<void()> handle_outgoing_connection,
		common::ContextualOnceCallback<void()> handle_incoming_connection,
		common::ContextualOnceCallback<void(std::string)> handle_unknown_connection);

		// Same as above, but for the outgoing ACL connection in particular (and no callbacks)
		void ReportOutgoingAclConnectionFailure();

		// Cancel an ACL connection. If the request is already outgoing, we will invoke cancel_connection, without clearing
		// the outgoing request. Otherwise, we will remove the request from the queue, invoke cancel_connection_completed,
		// and execute the next request in the queue.
		void CancelAclConnection(
		Address address,
		common::ContextualOnceCallback<void()> cancel_connection,
		common::ContextualOnceCallback<void()> cancel_connection_completed);

		// Schedule a Remote Name Request. When the request is started, start_request will be invoked. If the request is
		// cancelled before it is dequeued, cancel_request_completed will be invoked.
		void EnqueueRemoteNameRequest(
		Address address,
		common::ContextualOnceCallback<void()> start_request,
		common::ContextualOnceCallback<void()> cancel_request_completed);

		// Report that a Remote Name Request connection has completed, so we can resume popping from the queue.
		void ReportRemoteNameRequestCompletion(Address address);

		// Cancel an Remote Name Request. If the request is already outgoing, we will invoke cancel_request, without
		// clearing the outgoing request. Otherwise, we will invoke the cancel_request_completed callback registered on
		// the initial enqueue.
		void CancelRemoteNameRequest(Address address, common::ContextualOnceCallback<void()> cancel_request);

		private:
		struct impl;
		std::unique_ptr<impl> pimpl_;

		protected:
		void ListDependencies(ModuleList* list) const override;
		void Start() override;
		void Stop() override;
		std::string ToString() const override {
		return std::string("AclSchedulerModule");
		}

		public:
		static const ModuleFactory Factory;
		AclScheduler();
		~AclScheduler();
		};

		} // namespace acl_manager
		} // namespace hci
		} // namespace bluetooth
		No newline at end of file