Add initial l2cap dumpsys capabilities

Bug: 162655455
Test: atest --host bluetooth_test_gd
Tag: #gd-refactor

Change-Id: If7b5acca552cabe2032d95d4098833419bec4826

system/gd/Android.bp

@@ -454,11 +454,13 @@ genrule {
     cmd: "$(location flatc) -I packages/modules/Bluetooth/system/gd -b --schema -o $(genDir) $(in) ",
     srcs: [
         "dumpsys_data.fbs",
+        "l2cap/classic/l2cap_classic_module.fbs",
         "shim/dumpsys.fbs",
     ],
     out: [
-        "dumpsys_data.bfbs",
         "dumpsys.bfbs",
+        "dumpsys_data.bfbs",
+        "l2cap_classic_module.bfbs",
     ],
 }
 
@@ -470,11 +472,13 @@ genrule {
     cmd: "$(location flatc) -I packages/modules/Bluetooth/system/gd -o $(genDir) --cpp $(in) ",
     srcs: [
         "dumpsys_data.fbs",
+        "l2cap/classic/l2cap_classic_module.fbs",
         "shim/dumpsys.fbs",
     ],
     out: [
         "dumpsys_data_generated.h",
         "dumpsys_generated.h",
+        "l2cap_classic_module_generated.h",
     ],
 }
 

system/gd/dumpsys_data.fbs

 // Top level module dumpsys data schema
 include "module_unittest.fbs";
 include "shim/dumpsys.fbs";
+include "l2cap/classic/l2cap_classic_module.fbs";
 
 namespace bluetooth;
 
@@ -9,6 +10,7 @@ attribute "privacy";
 table DumpsysData {
     title:string;
     shim_dumpsys_data:bluetooth.shim.DumpsysModuleData (privacy:"Any");
+    l2cap_classic_dumpsys_data:bluetooth.l2cap.classic.L2capClassicModuleData (privacy:"Any");
     module_unittest_data:bluetooth.ModuleUnitTestData; // private
 }
 

system/gd/l2cap/Android.bp

@@ -13,6 +13,7 @@ filegroup {
         "classic/internal/link.cc",
         "classic/internal/link_manager.cc",
         "classic/internal/signalling_manager.cc",
+        "classic/internal/dumpsys_helper.cc",
         "classic/l2cap_classic_module.cc",
         "dynamic_channel.cc",
         "internal/basic_mode_channel_data_controller.cc",

system/gd/l2cap/classic/internal/dumpsys_helper.cc

+/*
+ * Copyright 2020 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 <string>
+
+#include "l2cap/classic/internal/dumpsys_helper.h"
+#include "l2cap/classic/internal/link_manager.h"
+#include "l2cap/internal/dynamic_channel_impl.h"
+#include "l2cap_classic_module_generated.h"
+#include "os/log.h"
+
+bluetooth::l2cap::classic::internal::DumpsysHelper::DumpsysHelper(const LinkManager& link_manager)
+    : link_manager_(link_manager) {}
+
+std::vector<flatbuffers::Offset<bluetooth::l2cap::classic::ChannelData>>
+bluetooth::l2cap::classic::internal::DumpsysHelper::DumpActiveDynamicChannels(
+    flatbuffers::FlatBufferBuilder* fb_builder,
+    const l2cap::internal::DynamicChannelAllocator& channel_allocator) const {
+  std::vector<flatbuffers::Offset<bluetooth::l2cap::classic::ChannelData>> channel_offsets;
+
+  for (auto it = channel_allocator.channels_.cbegin(); it != channel_allocator.channels_.cend(); ++it) {
+    ChannelDataBuilder builder(*fb_builder);
+    builder.add_cid(it->first);
+    channel_offsets.push_back(builder.Finish());
+  }
+  return channel_offsets;
+}
+
+std::vector<flatbuffers::Offset<bluetooth::l2cap::classic::LinkData>>
+bluetooth::l2cap::classic::internal::DumpsysHelper::DumpActiveLinks(flatbuffers::FlatBufferBuilder* fb_builder) const {
+  const std::unordered_map<hci::Address, Link>* links = &link_manager_.links_;
+
+  std::vector<flatbuffers::Offset<LinkData>> link_offsets;
+
+  for (auto it = links->cbegin(); it != links->cend(); ++it) {
+    auto link_address = fb_builder->CreateString(it->second.ToString());
+    auto dynamic_channel_offsets = DumpActiveDynamicChannels(fb_builder, it->second.dynamic_channel_allocator_);
+    auto dynamic_channels = fb_builder->CreateVector(dynamic_channel_offsets);
+
+    LinkDataBuilder builder(*fb_builder);
+    builder.add_address(link_address);
+    builder.add_dynamic_channels(dynamic_channels);
+    link_offsets.push_back(builder.Finish());
+  }
+  return link_offsets;
+}

system/gd/l2cap/classic/internal/dumpsys_helper.h

+/*
+ * Copyright 2020 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 "l2cap/classic/internal/link_manager.h"
+#include "l2cap/internal/dynamic_channel_allocator.h"
+#include "l2cap_classic_module_generated.h"
+
+namespace bluetooth {
+namespace l2cap {
+namespace classic {
+namespace internal {
+
+class DumpsysHelper {
+ public:
+  DumpsysHelper(const LinkManager& link_manager);
+
+  std::vector<flatbuffers::Offset<ChannelData>> DumpActiveDynamicChannels(
+      flatbuffers::FlatBufferBuilder* fb_builder,
+      const l2cap::internal::DynamicChannelAllocator& channel_allocator) const;
+  std::vector<flatbuffers::Offset<LinkData>> DumpActiveLinks(flatbuffers::FlatBufferBuilder* fb_builder) const;
+
+ private:
+  const LinkManager& link_manager_;
+};
+
+}  // namespace internal
+}  // namespace classic
+}  // namespace l2cap
+}  // namespace bluetooth

system/gd/l2cap/classic/internal/link.h

@@ -41,6 +41,7 @@ namespace classic {
 namespace internal {
 
 class LinkManager;
+class DumpsysHelper;
 
 class Link : public l2cap::internal::ILink, public hci::acl_manager::ConnectionManagementCallbacks {
  public:
@@ -177,6 +178,7 @@ class Link : public l2cap::internal::ILink, public hci::acl_manager::ConnectionM
   void OnDisconnection(hci::ErrorCode reason) override;
 
  private:
+  friend class DumpsysHelper;
   void connect_to_pending_dynamic_channels();
   void send_pending_configuration_requests();
 

system/gd/l2cap/classic/internal/link_manager.h

@@ -36,6 +36,8 @@ namespace l2cap {
 namespace classic {
 namespace internal {
 
+class DumpsysHelper;
+
 class LinkManager : public hci::acl_manager::ConnectionCallbacks {
  public:
   LinkManager(os::Handler* l2cap_handler, hci::AclManager* acl_manager,
@@ -82,6 +84,7 @@ class LinkManager : public hci::acl_manager::ConnectionCallbacks {
  private:
   // Handles requests from LinkSecurityInterface
   friend class LinkSecurityInterfaceImpl;
+  friend class DumpsysHelper;
   void handle_link_security_hold(hci::Address remote);
   void handle_link_security_release(hci::Address remote);
   void handle_link_security_disconnect(hci::Address remote);

system/gd/l2cap/classic/l2cap_classic_module.cc

@@ -15,6 +15,7 @@
  */
 #define LOG_TAG "l2cap2"
 
+#include <future>
 #include <memory>
 
 #include "common/bidi_queue.h"
@@ -22,16 +23,17 @@
 #include "hci/address.h"
 #include "hci/hci_layer.h"
 #include "hci/hci_packets.h"
+#include "l2cap/classic/internal/dumpsys_helper.h"
 #include "l2cap/classic/internal/dynamic_channel_service_manager_impl.h"
 #include "l2cap/classic/internal/fixed_channel_service_manager_impl.h"
 #include "l2cap/classic/internal/link_manager.h"
+#include "l2cap/classic/l2cap_classic_module.h"
 #include "l2cap/internal/parameter_provider.h"
+#include "l2cap_classic_module_generated.h"
 #include "module.h"
 #include "os/handler.h"
 #include "os/log.h"
 
-#include "l2cap/classic/l2cap_classic_module.h"
-
 namespace bluetooth {
 namespace l2cap {
 namespace classic {
@@ -44,6 +46,7 @@ struct L2capClassicModule::impl {
   impl(os::Handler* l2cap_handler, hci::AclManager* acl_manager)
       : l2cap_handler_(l2cap_handler), acl_manager_(acl_manager) {
     dynamic_channel_service_manager_impl_.SetSecurityEnforcementInterface(&default_security_module_impl_);
+    dumpsys_helper_ = std::make_unique<internal::DumpsysHelper>(link_manager_);
   }
   os::Handler* l2cap_handler_;
   hci::AclManager* acl_manager_;
@@ -52,6 +55,7 @@ struct L2capClassicModule::impl {
   internal::DynamicChannelServiceManagerImpl dynamic_channel_service_manager_impl_{l2cap_handler_};
   internal::LinkManager link_manager_{l2cap_handler_, acl_manager_, &fixed_channel_service_manager_impl_,
                                       &dynamic_channel_service_manager_impl_, &parameter_provider_};
+  std::unique_ptr<internal::DumpsysHelper> dumpsys_helper_;
 
   struct SecurityInterfaceImpl : public SecurityInterface {
     SecurityInterfaceImpl(impl* module_impl) : module_impl_(module_impl) {}
@@ -75,6 +79,10 @@ struct L2capClassicModule::impl {
     impl* module_impl_;
     bool registered_ = false;
   } security_interface_impl_{this};
+
+  void Dump(
+      std::promise<flatbuffers::Offset<L2capClassicModuleData>> promise,
+      flatbuffers::FlatBufferBuilder* fb_builder) const;
 };
 
 L2capClassicModule::L2capClassicModule() {}
@@ -122,6 +130,38 @@ SecurityInterface* L2capClassicModule::GetSecurityInterface(
   return &pimpl_->security_interface_impl_;
 }
 
+void L2capClassicModule::impl::Dump(
+    std::promise<flatbuffers::Offset<L2capClassicModuleData>> promise,
+    flatbuffers::FlatBufferBuilder* fb_builder) const {
+  auto title = fb_builder->CreateString("----- L2cap Classic Dumpsys -----");
+
+  std::vector<flatbuffers::Offset<bluetooth::l2cap::classic::LinkData>> link_offsets =
+      dumpsys_helper_->DumpActiveLinks(fb_builder);
+
+  auto active_links = fb_builder->CreateVector(link_offsets);
+
+  L2capClassicModuleDataBuilder builder(*fb_builder);
+  builder.add_title(title);
+  builder.add_active_links(active_links);
+  flatbuffers::Offset<L2capClassicModuleData> dumpsys_data = builder.Finish();
+
+  promise.set_value(dumpsys_data);
+}
+
+DumpsysDataFinisher L2capClassicModule::GetDumpsysData(flatbuffers::FlatBufferBuilder* fb_builder) const {
+  ASSERT(fb_builder != nullptr);
+
+  std::promise<flatbuffers::Offset<L2capClassicModuleData>> promise;
+  auto future = promise.get_future();
+  pimpl_->Dump(std::move(promise), fb_builder);
+
+  auto dumpsys_data = future.get();
+
+  return [dumpsys_data](DumpsysDataBuilder* dumpsys_builder) {
+    dumpsys_builder->add_l2cap_classic_dumpsys_data(dumpsys_data);
+  };
+}
+
 }  // namespace classic
 }  // namespace l2cap
 }  // namespace bluetooth

system/gd/l2cap/classic/l2cap_classic_module.fbs

+namespace bluetooth.l2cap.classic;
+
+attribute "privacy";
+
+table ChannelData {
+  cid:int;
+}
+
+table LinkData {
+  address:string;
+  dynamic_channels:[ChannelData];
+}
+
+table L2capClassicModuleData {
+    title:string (privacy:"Any");
+    active_links:[LinkData] (privacy:"Any");
+}
+
+root_type L2capClassicModuleData;

system/gd/l2cap/classic/l2cap_classic_module.h

@@ -58,6 +58,8 @@ class L2capClassicModule : public bluetooth::Module {
 
   std::string ToString() const override;
 
+  DumpsysDataFinisher GetDumpsysData(flatbuffers::FlatBufferBuilder* builder) const override;  // Module
+
  private:
   struct impl;
   std::unique_ptr<impl> pimpl_;

system/gd/l2cap/internal/dynamic_channel_allocator.h

@@ -29,6 +29,13 @@
 
 namespace bluetooth {
 namespace l2cap {
+
+namespace classic {
+namespace internal {
+class DumpsysHelper;
+}  // namespace internal
+}  // namespace classic
+
 namespace internal {
 
 class DynamicChannelImpl;
@@ -67,6 +74,7 @@ class DynamicChannelAllocator {
   void OnAclDisconnected(hci::ErrorCode hci_status);
 
  private:
+  friend class bluetooth::l2cap::classic::internal::DumpsysHelper;
   l2cap::internal::ILink* link_;
   os::Handler* l2cap_handler_;
   std::unordered_set<Cid> used_cid_;