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

Commit 5b8b306b authored by Jiyong Park's avatar Jiyong Park
Browse files

Refactor public_libraries.* 

- shorten the long const variables
- merge {oem|product}_public_libraries into extended_public_libraries

Bug: 130388701
Test: build & pass presubmit tests

Change-Id: I43be555041466118f2b2d188f5da3ff0d8ed7d8d
parent f8802e5f

libnativeloader/library_namespaces.cpp

+10 −13
Original line number Diff line number Diff line
@@ -122,7 +122,7 @@ void LibraryNamespaces::Initialize() { 
  // we might as well end up loading them from /system/lib or /product/lib

  // For now we rely on CTS test to catch things like this but

  // it should probably be addressed in the future.

  for (const auto& soname : android::base::Split(system_public_libraries(), ":")) {

  for (const auto& soname : android::base::Split(default_public_libraries(), ":")) {

    LOG_ALWAYS_FATAL_IF(dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE) == nullptr,

                        "Error preloading public library %s: %s", soname.c_str(), dlerror());

  }
@@ -186,7 +186,7 @@ NativeLoaderNamespace* LibraryNamespaces::Create(JNIEnv* env, uint32_t target_sd 
    is_native_bridge = NativeBridgeIsPathSupported(library_path.c_str());

  }



  std::string system_exposed_libraries = system_public_libraries();

  std::string system_exposed_libraries = default_public_libraries();

  const char* namespace_name = kClassloaderNamespaceName;

  android_namespace_t* vndk_ns = nullptr;

  if ((apk_origin == APK_ORIGIN_VENDOR ||
@@ -222,7 +222,7 @@ NativeLoaderNamespace* LibraryNamespaces::Create(JNIEnv* env, uint32_t target_sd 
    permitted_path = permitted_path + ":" + origin_lib_path;



    // Also give access to LLNDK libraries since they are available to vendors

    system_exposed_libraries = system_exposed_libraries + ":" + system_llndk_libraries().c_str();

    system_exposed_libraries = system_exposed_libraries + ":" + llndk_libraries().c_str();



    // Give access to VNDK-SP libraries from the 'vndk' namespace.

    vndk_ns = android_get_exported_namespace(kVndkNamespaceName);
@@ -235,13 +235,10 @@ NativeLoaderNamespace* LibraryNamespaces::Create(JNIEnv* env, uint32_t target_sd 
    ALOGD("classloader namespace configured for unbundled %s apk. library_path=%s",

          origin_partition, library_path.c_str());

  } else {

    // oem and product public libraries are NOT available to vendor apks, otherwise it

    // extended public libraries are NOT available to vendor apks, otherwise it

    // would be system->vendor violation.

    if (!oem_public_libraries().empty()) {

      system_exposed_libraries = system_exposed_libraries + ':' + oem_public_libraries();

    }

    if (!product_public_libraries().empty()) {

      system_exposed_libraries = system_exposed_libraries + ':' + product_public_libraries();

    if (!extended_public_libraries().empty()) {

      system_exposed_libraries = system_exposed_libraries + ':' + extended_public_libraries();

    }

  }

  std::string runtime_exposed_libraries = runtime_public_libraries();
@@ -292,9 +289,9 @@ NativeLoaderNamespace* LibraryNamespaces::Create(JNIEnv* env, uint32_t target_sd 
      }

    }



    if (vndk_ns != nullptr && !system_vndksp_libraries().empty()) {

    if (vndk_ns != nullptr && !vndksp_libraries().empty()) {

      // vendor apks are allowed to use VNDK-SP libraries.

      if (!android_link_namespaces(ns, vndk_ns, system_vndksp_libraries().c_str())) {

      if (!android_link_namespaces(ns, vndk_ns, vndksp_libraries().c_str())) {

        *error_msg = dlerror();

        return nullptr;

      }
@@ -383,7 +380,7 @@ bool LibraryNamespaces::InitPublicNamespace(const char* library_path, std::strin 
  // code is one example) unknown to linker in which  case linker uses anonymous

  // namespace. The second argument specifies the search path for the anonymous

  // namespace which is the library_path of the classloader.

  initialized_ = android_init_anonymous_namespace(system_public_libraries().c_str(),

  initialized_ = android_init_anonymous_namespace(default_public_libraries().c_str(),

                                                  is_native_bridge ? nullptr : library_path);

  if (!initialized_) {

    *error_msg = dlerror();
@@ -392,7 +389,7 @@ bool LibraryNamespaces::InitPublicNamespace(const char* library_path, std::strin 


  // and now initialize native bridge namespaces if necessary.

  if (NativeBridgeInitialized()) {

    initialized_ = NativeBridgeInitAnonymousNamespace(system_public_libraries().c_str(),

    initialized_ = NativeBridgeInitAnonymousNamespace(default_public_libraries().c_str(),

                                                      is_native_bridge ? library_path : nullptr);

    if (!initialized_) {

      *error_msg = NativeBridgeGetError();

libnativeloader/public_libraries.cpp

+27 −44
Original line number Diff line number Diff line
@@ -34,17 +34,13 @@ namespace android::nativeloader { 
using namespace std::string_literals;



namespace {

// TODO(b/130388701) simplify the names below

constexpr const char kPublicNativeLibrariesSystemConfigPathFromRoot[] = "/etc/public.libraries.txt";

constexpr const char kPublicNativeLibrariesExtensionConfigPrefix[] = "public.libraries-";

constexpr const size_t kPublicNativeLibrariesExtensionConfigPrefixLen =

    sizeof(kPublicNativeLibrariesExtensionConfigPrefix) - 1;

constexpr const char kPublicNativeLibrariesExtensionConfigSuffix[] = ".txt";

constexpr const size_t kPublicNativeLibrariesExtensionConfigSuffixLen =

    sizeof(kPublicNativeLibrariesExtensionConfigSuffix) - 1;

constexpr const char kPublicNativeLibrariesVendorConfig[] = "/vendor/etc/public.libraries.txt";

constexpr const char kLlndkNativeLibrariesSystemConfigPathFromRoot[] = "/etc/llndk.libraries.txt";

constexpr const char kVndkspNativeLibrariesSystemConfigPathFromRoot[] = "/etc/vndksp.libraries.txt";



constexpr const char* kDefaultPublicLibrariesFile = "/etc/public.libraries.txt";

constexpr const char* kExtendedPublicLibrariesFilePrefix = "public.libraries-";

constexpr const char* kExtendedPublicLibrariesFileSuffix = ".txt";

constexpr const char* kVendorPublicLibrariesFile = "/vendor/etc/public.libraries.txt";

constexpr const char* kLlndkLibrariesFile = "/system/etc/llndk.libraries.txt";

constexpr const char* kVndkLibrariesFile = "/system/etc/vndksp.libraries.txt";



const std::vector<const std::string> kRuntimePublicLibraries = {

    "libicuuc.so",
@@ -53,26 +49,26 @@ const std::vector<const std::string> kRuntimePublicLibraries = { 


constexpr const char* kRuntimeApexLibPath = "/apex/com.android.runtime/" LIB;



// TODO(b/130388701): do we need this?

std::string root_dir() {

  static const char* android_root_env = getenv("ANDROID_ROOT");

  return android_root_env != nullptr ? android_root_env : "/system";

}



bool debuggable() {

  bool debuggable = false;

  debuggable = android::base::GetBoolProperty("ro.debuggable", false);

  static bool debuggable = android::base::GetBoolProperty("ro.debuggable", false);

  return debuggable;

}



std::string vndk_version_str() {

  std::string version = android::base::GetProperty("ro.vndk.version", "");

  static std::string version = android::base::GetProperty("ro.vndk.version", "");

  if (version != "" && version != "current") {

    return "." + version;

  }

  return "";

}



void insert_vndk_version_str(std::string* file_name) {

void InsertVndkVersionStr(std::string* file_name) {

  CHECK(file_name != nullptr);

  size_t insert_pos = file_name->find_last_of(".");

  if (insert_pos == std::string::npos) {
@@ -142,11 +138,10 @@ void ReadExtensionLibraries(const char* dirname, std::vector<std::string>* sonam 
        continue;

      }

      const std::string filename(ent->d_name);

      if (android::base::StartsWith(filename, kPublicNativeLibrariesExtensionConfigPrefix) &&

          android::base::EndsWith(filename, kPublicNativeLibrariesExtensionConfigSuffix)) {

        const size_t start = kPublicNativeLibrariesExtensionConfigPrefixLen;

        const size_t end = filename.size() - kPublicNativeLibrariesExtensionConfigSuffixLen;

        const std::string company_name = filename.substr(start, end - start);

      std::string_view fn = filename;

      if (android::base::ConsumePrefix(&fn, kExtendedPublicLibrariesFilePrefix) &&

          android::base::ConsumeSuffix(&fn, kExtendedPublicLibrariesFileSuffix)) {

        const std::string company_name(fn);

        const std::string config_file_path = dirname + "/"s + filename;

        LOG_ALWAYS_FATAL_IF(

            company_name.empty(),
@@ -178,11 +173,11 @@ void ReadExtensionLibraries(const char* dirname, std::vector<std::string>* sonam 


}  // namespace



const std::string& system_public_libraries() {

const std::string& default_public_libraries() {

  static bool cached = false;

  static std::string list;

  if (!cached) {

    std::string config_file = root_dir() + kPublicNativeLibrariesSystemConfigPathFromRoot;

    std::string config_file = root_dir() + kDefaultPublicLibrariesFile;

    std::vector<std::string> sonames;

    std::string error_msg;

    LOG_ALWAYS_FATAL_IF(!ReadConfig(config_file, &sonames, always_true, &error_msg),
@@ -251,35 +246,23 @@ const std::string& vendor_public_libraries() { 
  if (!cached) {

    // This file is optional, quietly ignore if the file does not exist.

    std::vector<std::string> sonames;

    ReadConfig(kPublicNativeLibrariesVendorConfig, &sonames, always_true, nullptr);

    ReadConfig(kVendorPublicLibrariesFile, &sonames, always_true, nullptr);

    list = android::base::Join(sonames, ':');

    cached = true;

  }

  return list;

}



// read /system/etc/public.libraries-<companyname>.txt which contain partner defined

// read /system/etc/public.libraries-<companyname>.txt and

// /product/etc/public.libraries-<companyname>.txt which contain partner defined

// system libs that are exposed to apps. The libs in the txt files must be

// named as lib<name>.<companyname>.so.

const std::string& oem_public_libraries() {

const std::string& extended_public_libraries() {

  static bool cached = false;

  static std::string list;

  if (!cached) {

    std::vector<std::string> sonames;

    ReadExtensionLibraries("/system/etc", &sonames);

    list = android::base::Join(sonames, ':');

    cached = true;

  }

  return list;

}



// read /product/etc/public.libraries-<companyname>.txt which contain partner defined

// product libs that are exposed to apps.

const std::string& product_public_libraries() {

  static bool cached = false;

  static std::string list;

  if (!cached) {

    std::vector<std::string> sonames;

    ReadExtensionLibraries("/product/etc", &sonames);

    list = android::base::Join(sonames, ':');

    cached = true;
@@ -287,12 +270,12 @@ const std::string& product_public_libraries() { 
  return list;

}



const std::string& system_llndk_libraries() {

const std::string& llndk_libraries() {

  static bool cached = false;

  static std::string list;

  if (!cached) {

    std::string config_file = root_dir() + kLlndkNativeLibrariesSystemConfigPathFromRoot;

    insert_vndk_version_str(&config_file);

    std::string config_file = kLlndkLibrariesFile;

    InsertVndkVersionStr(&config_file);

    std::vector<std::string> sonames;

    ReadConfig(config_file, &sonames, always_true, nullptr);

    list = android::base::Join(sonames, ':');
@@ -301,12 +284,12 @@ const std::string& system_llndk_libraries() { 
  return list;

}



const std::string& system_vndksp_libraries() {

const std::string& vndksp_libraries() {

  static bool cached = false;

  static std::string list;

  if (!cached) {

    std::string config_file = root_dir() + kVndkspNativeLibrariesSystemConfigPathFromRoot;

    insert_vndk_version_str(&config_file);

    std::string config_file = kVndkLibrariesFile;

    InsertVndkVersionStr(&config_file);

    std::vector<std::string> sonames;

    ReadConfig(config_file, &sonames, always_true, nullptr);

    list = android::base::Join(sonames, ':');

libnativeloader/public_libraries.h

+4 −6
Original line number Diff line number Diff line
@@ -22,13 +22,11 @@ namespace android::nativeloader { 
// These provide the list of libraries that are available to the namespace for apps.

// Not all of the libraries are available to apps. Depending on the context,

// e.g., if it is a vendor app or not, different set of libraries are made available.

// TODO(b/130388701) rename these.

const std::string& system_public_libraries();

const std::string& default_public_libraries();

const std::string& runtime_public_libraries();

const std::string& vendor_public_libraries();

const std::string& oem_public_libraries();

const std::string& product_public_libraries();

const std::string& system_llndk_libraries();

const std::string& system_vndksp_libraries();

const std::string& extended_public_libraries();

const std::string& llndk_libraries();

const std::string& vndksp_libraries();



};  // namespace android::nativeloader