Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ee9f3813 authored by Zach Johnson's avatar Zach Johnson
Browse files

rusty-gd: move init_flag parsing to rust 

all that macro goodness comes to life

Bug: 171749953
Tag: #gd-refactor
Test: gd/cert/run --rhost SimpleHalTest
Change-Id: I163111bc87267d8d35ed454c2d9a100f9290f274
parent 5f626fd8

system/btif/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -115,7 +115,6 @@ cc_library_static { 
    cflags: [

        "-DBUILDCFG",

    ],



}



// btif unit tests for target

system/build/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -97,6 +97,9 @@ fluoride_defaults { 
            enabled: false,

        },

    },

    generated_headers: [

        "libbt_common_bridge_header",

    ],

}



// Enables code coverage for a set of source files. Must be combined with

system/gd/common/init_flags.cc

+7 −65
Original line number Diff line number Diff line
@@ -22,20 +22,10 @@ 


#include "common/strings.h"

#include "os/log.h"

#include "src/init_flags.rs.h"



namespace bluetooth {

namespace common {



bool InitFlags::btaa_hci_log_enabled = false;

bool InitFlags::gd_core_enabled = false;

bool InitFlags::gd_advertising_enabled = false;

bool InitFlags::gd_security_enabled = false;

bool InitFlags::gd_acl_enabled = false;

bool InitFlags::gd_l2cap_enabled = false;

bool InitFlags::gd_hci_enabled = false;

bool InitFlags::gd_controller_enabled = false;

bool InitFlags::gatt_robust_caching_enabled = false;

bool InitFlags::logging_debug_enabled_for_all = false;

std::unordered_map<std::string, bool> InitFlags::logging_debug_explicit_tag_settings = {};
@@ -52,33 +42,16 @@ bool ParseBoolFlag(const std::vector<std::string>& flag_pair, const std::string& 
}



void InitFlags::Load(const char** flags) {

  rust::Vec<rust::String> rusted_flags = rust::Vec<rust::String>();

  while (flags != nullptr && *flags != nullptr) {

    rusted_flags.push_back(rust::String(*flags));

    flags++;

  }

  init_flags_load(std::move(rusted_flags));



  SetAll(false);

  while (flags != nullptr && *flags != nullptr) {

    std::string flag_element = *flags;

    auto flag_pair = StringSplit(flag_element, "=", 2);

    if (flag_pair.size() != 2) {

      LOG_ERROR("Bad flag %s, must be in <FLAG>=<VALUE> format", flag_element.c_str());

      flags++;

      continue;

    }



    ParseBoolFlag(flag_pair, "INIT_gd_core", &gd_core_enabled);

    ParseBoolFlag(flag_pair, "INIT_gd_advertising", &gd_advertising_enabled);

    ParseBoolFlag(flag_pair, "INIT_gd_security", &gd_security_enabled);

    ParseBoolFlag(flag_pair, "INIT_gd_acl", &gd_acl_enabled);

    ParseBoolFlag(flag_pair, "INIT_gd_l2cap", &gd_l2cap_enabled);

    ParseBoolFlag(flag_pair, "INIT_gd_hci", &gd_hci_enabled);

    ParseBoolFlag(flag_pair, "INIT_gd_controller", &gd_controller_enabled);

    ParseBoolFlag(flag_pair, "INIT_gatt_robust_caching", &gatt_robust_caching_enabled);

    ParseBoolFlag(flag_pair, "INIT_logging_debug_enabled_for_all", &logging_debug_enabled_for_all);

    ParseBoolFlag(flag_pair, "INIT_btaa_hci", &btaa_hci_log_enabled);

    if ("INIT_logging_debug_enabled_for_tags" == flag_pair[0]) {

      auto tags = StringSplit(flag_pair[1], ",");

      for (const auto& tag : tags) {
@@ -97,23 +70,6 @@ void InitFlags::Load(const char** flags) { 
    flags++;

  }



  if (gd_core_enabled && !gd_security_enabled) {

    gd_security_enabled = true;

  }

  if (gd_security_enabled && !gd_acl_enabled) {

    gd_acl_enabled = true;

  }

  if (gd_acl_enabled && !gd_controller_enabled) {

    gd_controller_enabled = true;

  }

  if (gd_l2cap_enabled) {

    gd_acl_enabled = false;

    gd_hci_enabled = true;

  }

  if (gd_controller_enabled && !gd_hci_enabled) {

    gd_hci_enabled = true;

  }



  std::vector<std::string> logging_debug_enabled_tags;

  std::vector<std::string> logging_debug_disabled_tags;

  for (const auto& tag_setting : logging_debug_explicit_tag_settings) {
@@ -124,35 +80,21 @@ void InitFlags::Load(const char** flags) { 
    }

  }



  LOG_INFO(

      "Flags loaded: gd_advertising_enabled=%s, gd_security_enabled=%s, gd_acl_enabled=%s, gd_hci_enabled=%s, "

      "gd_controller_enabled=%s, gd_core_enabled=%s, logging_debug_enabled_for_all=%s, "

      "logging_debug_enabled_tags=%s, logging_debug_disabled_tags=%s, btaa_hci_log_enabled=%s",

      ToString(gd_advertising_enabled).c_str(),

      ToString(gd_security_enabled).c_str(),

      ToString(gd_acl_enabled).c_str(),

      ToString(gd_hci_enabled).c_str(),

      ToString(gd_controller_enabled).c_str(),

      ToString(gd_core_enabled).c_str(),

      ToString(logging_debug_enabled_for_all).c_str(),

      StringJoin(logging_debug_enabled_tags, ",").c_str(),

      StringJoin(logging_debug_disabled_tags, ",").c_str(),

      ToString(btaa_hci_log_enabled).c_str());

  rust::Vec<rust::String> rusted_flags = rust::Vec<rust::String>();

  while (flags != nullptr && *flags != nullptr) {

    rusted_flags.push_back(rust::String(*flags));

    flags++;

  }

  init_flags::load(std::move(rusted_flags));

}



void InitFlags::SetAll(bool value) {

  gd_core_enabled = value;

  gd_advertising_enabled = value;

  gd_acl_enabled = value;

  gd_security_enabled = value;

  gd_controller_enabled = value;

  gd_hci_enabled = value;

  gatt_robust_caching_enabled = value;

  logging_debug_enabled_for_all = value;

  logging_debug_explicit_tag_settings.clear();

}



void InitFlags::SetAllForTesting() {

  init_flags::set_all_for_testing();

  SetAll(true);

}

system/gd/common/init_flags.h

+1 −45
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 


#include <string>

#include <unordered_map>

#include "src/init_flags.rs.h"



namespace bluetooth {

namespace common {
@@ -26,38 +27,6 @@ class InitFlags final { 
 public:

  static void Load(const char** flags);



  static bool GdAdvertisingEnabled() {

    return gd_advertising_enabled;

  }



  static bool GdSecurityEnabled() {

    return gd_security_enabled;

  }



  static bool GdAclEnabled() {

    return gd_acl_enabled;

  }



  static bool GdHciEnabled() {

    return gd_hci_enabled;

  }



  static bool GdControllerEnabled() {

    return gd_controller_enabled;

  }



  static bool GdL2capEnabled() {

    return gd_l2cap_enabled;

  }



  static bool GdCoreEnabled() {

    return gd_core_enabled;

  }



  static bool GattRobustCachingEnabled() {

    return gatt_robust_caching_enabled;

  }



  inline static bool IsDebugLoggingEnabledForTag(const std::string& tag) {

    auto tag_setting = logging_debug_explicit_tag_settings.find(tag);

    if (tag_setting != logging_debug_explicit_tag_settings.end()) {
@@ -70,26 +39,13 @@ class InitFlags final { 
    return logging_debug_enabled_for_all;

  }



  static bool BtaaHciLogEnabled() {

    return btaa_hci_log_enabled;

  }



  static void SetAllForTesting();



 private:

  static void SetAll(bool value);

  static bool gd_advertising_enabled;

  static bool gd_security_enabled;

  static bool gd_acl_enabled;

  static bool gd_hci_enabled;

  static bool gd_controller_enabled;

  static bool gd_l2cap_enabled;

  static bool gd_core_enabled;

  static bool gatt_robust_caching_enabled;

  static bool logging_debug_enabled_for_all;

  // save both log allow list and block list in the map to save hashing time

  static std::unordered_map<std::string, bool> logging_debug_explicit_tag_settings;

  static bool btaa_hci_log_enabled;

};



}  // namespace common

system/gd/common/init_flags_test.cc

+0 −59
Original line number Diff line number Diff line
@@ -22,56 +22,6 @@ 


using bluetooth::common::InitFlags;



TEST(InitFlagsTest, test_load_nullptr) {

  InitFlags::Load(nullptr);

  ASSERT_FALSE(InitFlags::GdCoreEnabled());

}



TEST(InitFlagsTest, test_load_empty) {

  const char* input[] = {nullptr};

  InitFlags::Load(input);

  ASSERT_FALSE(InitFlags::GdCoreEnabled());

}



TEST(InitFlagsTest, test_load_garbage) {

  const char* input[] = {"some random non-existent flag", nullptr};

  InitFlags::Load(input);

  ASSERT_FALSE(InitFlags::GdCoreEnabled());

}



TEST(InitFlagsTest, test_load_core) {

  const char* input[] = {"INIT_gd_core=true", nullptr};

  InitFlags::Load(input);

  ASSERT_TRUE(InitFlags::GdCoreEnabled());

  ASSERT_TRUE(InitFlags::GdControllerEnabled());

  ASSERT_TRUE(InitFlags::GdHciEnabled());

  ASSERT_FALSE(InitFlags::BtaaHciLogEnabled());

}



TEST(InitFlagsTest, test_load_controller) {

  const char* input[] = {"INIT_gd_controller=true", nullptr};

  InitFlags::Load(input);

  ASSERT_FALSE(InitFlags::GdCoreEnabled());

  ASSERT_TRUE(InitFlags::GdControllerEnabled());

  ASSERT_TRUE(InitFlags::GdHciEnabled());

  ASSERT_FALSE(InitFlags::BtaaHciLogEnabled());

}



TEST(InitFlagsTest, test_load_hci) {

  const char* input[] = {"INIT_gd_hci=true", nullptr};

  InitFlags::Load(input);

  ASSERT_FALSE(InitFlags::GdCoreEnabled());

  ASSERT_FALSE(InitFlags::GdControllerEnabled());

  ASSERT_TRUE(InitFlags::GdHciEnabled());

  ASSERT_FALSE(InitFlags::BtaaHciLogEnabled());

}



TEST(InitFlagsTest, test_load_gatt_robust_caching) {

  const char* input[] = {"INIT_gatt_robust_caching=true", nullptr};

  InitFlags::Load(input);

  ASSERT_TRUE(InitFlags::GattRobustCachingEnabled());

}



TEST(InitFlagsTest, test_enable_debug_logging_for_all) {

  const char* input[] = {"INIT_logging_debug_enabled_for_all=true", nullptr};

  InitFlags::Load(input);
@@ -112,12 +62,3 @@ TEST(InitFlagsTest, test_debug_logging_multiple_flags) { 
  ASSERT_FALSE(InitFlags::IsDebugLoggingEnabledForTag("Foo"));

  ASSERT_FALSE(InitFlags::IsDebugLoggingEnabledForAll());

}
 


TEST(InitFlagsTest, test_load_btaa_hci_log) {

  const char* input[] = {"INIT_btaa_hci=true", nullptr};

  InitFlags::Load(input);

  ASSERT_TRUE(InitFlags::BtaaHciLogEnabled());

  ASSERT_FALSE(InitFlags::GdCoreEnabled());

  ASSERT_FALSE(InitFlags::GdControllerEnabled());

  ASSERT_FALSE(InitFlags::GdHciEnabled());

}