Android system — 链接器命名空间共享库设置方法（Android 11后） ...

1. 应用进程

1.1 应用进程类加载器的命名空间初始化

  在应用步伐对应的可执行文件app_process根据/linkerconfig/ld.config.txt设置文件初始化命名空间之后，每当应用步伐创建一个类加载器classloader并调用System.loadLibrary加载so库时都会创建一个与此类加载器对应的命名空间。从源码角度分析一下这个过程，System.loadLibrary函数末了会调用OpenNativeLibrary函数。
1.1.1 OpenNativeLibrary

System.loadLibrary()-->nativeLoad()-->Runtime.c::Runtime_nativeLoad()-->JVM_NativeLoad()-->Openjdkjvm.cc::JVM_NativeLoad()-->java_vm_ext.cc:oadNativeLibrary()-->native_loader.cpp::OpenNativeLibrary() 也就是java层的System.loadLibrary()终极会调用libnativeloader.so的OpenNativeLibrary函数。

• OpenNativeLibrary先判断classloader类加载器是否为空，如果为空直接调用android_dlopen_ext加载库文件
  
• 如果判断classloader类加载器不为空，并且classloader类加载器没有对应的命名空间（第一次调用System.loadLibrary)就调用LibraryNamespaces::Create创建新的命名空间。
  

1. void* OpenNativeLibrary(JNIEnv* env, int32_t target_sdk_version, const char* path,
2.                         jobject class_loader, const char* caller_location, jstring library_path,
3.                         bool* needs_native_bridge, char** error_msg) {
4. #if defined(ART_TARGET_ANDROID)
5.   UNUSED(target_sdk_version);
7.   if (class_loader == nullptr) { //如果类加载器为空直接调用android_dlopen_ext加载库文件
8.     *needs_native_bridge = false;
9.     if (caller_location != nullptr) {
10.       android_namespace_t* boot_namespace = FindExportedNamespace(caller_location);
11.       if (boot_namespace != nullptr) {
12.         const android_dlextinfo dlextinfo = {
13.             .flags = ANDROID_DLEXT_USE_NAMESPACE,
14.             .library_namespace = boot_namespace,
15.         };
16.         void* handle = android_dlopen_ext(path, RTLD_NOW, &dlextinfo);
17.         if (handle == nullptr) {
18.           *error_msg = strdup(dlerror());
19.         }
20.         return handle;
21.       }
22.     }
24.     // Check if the library is in NATIVELOADER_DEFAULT_NAMESPACE_LIBS and should
25.     // be loaded from the kNativeloaderExtraLibs namespace.
26.     {
27.       Result<void*> handle = TryLoadNativeloaderExtraLib(path);
28.       if (!handle.ok()) {
29.         *error_msg = strdup(handle.error().message().c_str());
30.         return nullptr;
31.       }
32.       if (handle.value() != nullptr) {
33.         return handle.value();
34.       }
35.     }
37.     // Fall back to the system namespace. This happens for preloaded JNI
38.     // libraries in the zygote.
39.     // TODO(b/185833744): Investigate if this should fall back to the app main
40.     // namespace (aka anonymous namespace) instead.
41.     void* handle = OpenSystemLibrary(path, RTLD_NOW);
42.     if (handle == nullptr) {
43.       *error_msg = strdup(dlerror());
44.     }
45.     return handle;
46.   }
48.   std::lock_guard<std::mutex> guard(g_namespaces_mutex);
49.   NativeLoaderNamespace* ns;
51.   if ((ns = g_namespaces->FindNamespaceByClassLoader(env, class_loader)) == nullptr) { //如果类加载器不为空，且类加载器没有对应的命名空间就新创建一个
52.     // This is the case where the classloader was not created by ApplicationLoaders
53.     // In this case we create an isolated not-shared namespace for it.
54.     Result<NativeLoaderNamespace*> isolated_ns =
55.         CreateClassLoaderNamespaceLocked(env,
56.                                          target_sdk_version,
57.                                          class_loader,
58.                                          /*is_shared=*/false,
59.                                          /*dex_path=*/nullptr,
60.                                          library_path,
61.                                          /*permitted_path=*/nullptr,
62.                                          /*uses_library_list=*/nullptr);
63.     if (!isolated_ns.ok()) {
64.       *error_msg = strdup(isolated_ns.error().message().c_str());
65.       return nullptr;
66.     } else {
67.       ns = *isolated_ns;
68.     }
69.   }
71.   return OpenNativeLibraryInNamespace(ns, path, needs_native_bridge, error_msg);

复制代码

在CreateClassLoaderNamespaceLocked中我们可以看到调用了LibraryNamespaces::Create创建新的命名空间

2. Result<NativeLoaderNamespace*> CreateClassLoaderNamespaceLocked(JNIEnv* env,
3.                                                                 int32_t target_sdk_version,
4.                                                                 jobject class_loader,
5.                                                                 bool is_shared,
6.                                                                 jstring dex_path,
7.                                                                 jstring library_path,
8.                                                                 jstring permitted_path,
9.                                                                 jstring uses_library_list)
10.     REQUIRES(g_namespaces_mutex) {
11.   Result<NativeLoaderNamespace*> ns = g_namespaces->Create(env,
12.                                                            target_sdk_version,
13.                                                            class_loader,
14.                                                            is_shared,
15.                                                            dex_path,
16.                                                            library_path,
17.                                                            permitted_path,
18.                                                            uses_library_list);
19.   if (!ns.ok()) {
20.     return ns;
21.   }
22.   Result<void> linked = CreateNativeloaderDefaultNamespaceLibsLink(*ns.value());
23.   if (!linked.ok()) {
24.     return linked.error();
25.   }
26.   return ns;
27. }

复制代码

1.1.2 LibraryNamespaces::Create

• 先调用android_create_namespace创建一个clns命名空间
  
• 调用android_linker_namespace设置新创建的命名空间链接到system、APEX和vendor等命名空间
  
• 设置链接到system、APEX等命名空间的共享库
  

2. Result<NativeLoaderNamespace*> LibraryNamespaces::Create(JNIEnv* env, uint32_t target_sdk_version,
3.                                                          jobject class_loader, bool is_shared,
4.                                                          jstring dex_path_j,
5.                                                          jstring java_library_path,
6.                                                          jstring java_permitted_path,
7.                                                          jstring uses_library_list) {
8.   std::string library_path;  // empty string by default.
9.   std::string dex_path;
11.   ......
13.   // Create the app namespace
14.   NativeLoaderNamespace* parent_ns = FindParentNamespaceByClassLoader(env, class_loader);
15.   // Heuristic: the first classloader with non-empty library_path is assumed to
16.   // be the main classloader for app
17.   // TODO(b/139178525) remove this heuristic by determining this in LoadedApk (or its
18.   // friends) and then passing it down to here.
19.   bool is_main_classloader = app_main_namespace_ == nullptr && !library_path.empty();
20.   // Policy: the namespace for the main classloader is also used as the
21.   // anonymous namespace.
22.   bool also_used_as_anonymous = is_main_classloader;
23.   // Note: this function is executed with g_namespaces_mutex held, thus no
24.   // racing here.
25.   //创建命名空间，namespace_name为kClassloaderNamespaceName = "clns"
26.   auto app_ns = NativeLoaderNamespace::Create(
27.       namespace_name, library_path, permitted_path, parent_ns, is_shared,
28.       target_sdk_version < 24 /* is_exempt_list_enabled */, also_used_as_anonymous);
29.   if (!app_ns.ok()) {
30.     return app_ns.error();
31.   }
32.   // ... and link to other namespaces to allow access to some public libraries
33.   bool is_bridged = app_ns->IsBridged();
35.   auto system_ns = NativeLoaderNamespace::GetSystemNamespace(is_bridged);
36.   if (!system_ns.ok()) {
37.     return system_ns.error();
38.   }
39.   // 新创建的命名空间链接到system，共享库设置为system_exposed_libraries
40.   auto linked = app_ns->Link(&system_ns.value(), system_exposed_libraries);
41.   if (!linked.ok()) {
42.     return linked.error();
43.   }
45.   for (const auto&[apex_ns_name, public_libs] : apex_public_libraries()) {
46.     auto ns = NativeLoaderNamespace::GetExportedNamespace(apex_ns_name, is_bridged);
47.     // Even if APEX namespace is visible, it may not be available to bridged.
48.     if (ns.ok()) {
49.       // 新创建的命名空间链接到APEX，共享库设置为public_libs
50.       linked = app_ns->Link(&ns.value(), public_libs);
51.       if (!linked.ok()) {
52.         return linked.error();
53.       }
54.     }
55.   }
57.   // Give access to VNDK-SP libraries from the 'vndk' namespace for unbundled vendor apps.
58.   if (unbundled_app_origin == APK_ORIGIN_VENDOR && !vndksp_libraries_vendor().empty()) {
59.     auto vndk_ns = NativeLoaderNamespace::GetExportedNamespace(kVndkNamespaceName, is_bridged);
60.     if (vndk_ns.ok()) {
61.       // 新创建的命名空间链接到vndk，共享库设置为vndksp_libraries_vendor()
62.       linked = app_ns->Link(&vndk_ns.value(), vndksp_libraries_vendor());
63.       if (!linked.ok()) {
64.         return linked.error();
65.       }
66.     }
67.   }
69.   // Give access to VNDK-SP libraries from the 'vndk_product' namespace for unbundled product apps.
70.   if (unbundled_app_origin == APK_ORIGIN_PRODUCT && !vndksp_libraries_product().empty()) {
71.     auto vndk_ns = NativeLoaderNamespace::GetExportedNamespace(kVndkProductNamespaceName, is_bridged);
72.     if (vndk_ns.ok()) {
73.       linked = app_ns->Link(&vndk_ns.value(), vndksp_libraries_product());
74.       if (!linked.ok()) {
75.         return linked.error();
76.       }
77.     }
78.   }
80.   for (const std::string& each_jar_path : android::base::Split(dex_path, ":")) {
81.     auto apex_ns_name = FindApexNamespaceName(each_jar_path);
82.     if (apex_ns_name.ok()) {
83.       const auto& jni_libs = apex_jni_libraries(*apex_ns_name);
84.       if (jni_libs != "") {
85.         auto apex_ns = NativeLoaderNamespace::GetExportedNamespace(*apex_ns_name, is_bridged);
86.         if (apex_ns.ok()) {
87.           linked = app_ns->Link(&apex_ns.value(), jni_libs);
88.           if (!linked.ok()) {
89.             return linked.error();
90.           }
91.         }
92.       }
93.     }
94.   }
96.   auto vendor_libs = filter_public_libraries(target_sdk_version, uses_libraries,
97.                                              vendor_public_libraries());
98.   if (!vendor_libs.empty()) {
99.     auto vendor_ns = NativeLoaderNamespace::GetExportedNamespace(kVendorNamespaceName, is_bridged);
100.     // when vendor_ns is not configured, link to the system namespace
101.     auto target_ns = vendor_ns.ok() ? vendor_ns : system_ns;
102.     if (target_ns.ok()) {
103.       linked = app_ns->Link(&target_ns.value(), vendor_libs);
104.       if (!linked.ok()) {
105.         return linked.error();
106.       }
107.     }
108.   }
110.   auto product_libs = filter_public_libraries(target_sdk_version, uses_libraries,
111.                                               product_public_libraries());
112.   if (!product_libs.empty()) {
113.     auto target_ns = system_ns;
114.     if (is_product_vndk_version_defined()) {
115.       // If ro.product.vndk.version is defined, product namespace provides the product libraries.
116.       target_ns = NativeLoaderNamespace::GetExportedNamespace(kProductNamespaceName, is_bridged);
117.     }
118.     if (target_ns.ok()) {
119.       linked = app_ns->Link(&target_ns.value(), product_libs);
120.       if (!linked.ok()) {
121.         return linked.error();
122.       }
123.     } else {
124.       // The linkerconfig must have a problem on defining the product namespace in the system
125.       // section. Skip linking product namespace. This will not affect most of the apps. Only the
126.       // apps that requires the product public libraries will fail.
127.       ALOGW("Namespace for product libs not found: %s", target_ns.error().message().c_str());
128.     }
129.   }
131.   auto& emplaced = namespaces_.emplace_back(
132.       std::make_pair(env->NewWeakGlobalRef(class_loader), *app_ns));
133.   if (is_main_classloader) {
134.     app_main_namespace_ = &emplaced.second;
135.   }
136.   return &emplaced.second;
137. }

复制代码

1.2 设置共享库位置

通过上面的代码跟踪我们会发现，实在在Android 11后，应用进程共享库的设置位置都在public_libraries.cpp中

1. // art/libnativeloader/public_libraries.cpp
2. namespace {
4. constexpr const char* kDefaultPublicLibrariesFile = "/etc/public.libraries.txt";
5. constexpr const char* kExtendedPublicLibrariesFilePrefix = "public.libraries-";
6. constexpr const char* kExtendedPublicLibrariesFileSuffix = ".txt";
7. constexpr const char* kApexLibrariesConfigFile = "/linkerconfig/apex.libraries.config.txt";
8. constexpr const char* kVendorPublicLibrariesFile = "/vendor/etc/public.libraries.txt";
9. constexpr const char* kLlndkLibrariesFile = "/apex/com.android.vndk.v{}/etc/llndk.libraries.{}.txt";
10. constexpr const char* kVndkLibrariesFile = "/apex/com.android.vndk.v{}/etc/vndksp.libraries.{}.txt";

复制代码

只要在命名空间对应的设置文件中加上自己必要的共享库即可
2. native进程

2.1 native 命名空间设置初始化

native进程的so库是直接通过dlopen打开的，而其对应的命名空间也是直接通过linker举行判断的，并没有调用到libnativeloader.so，因此native进程的设置方式也与应用进程不同
2.1.1 android_namespace_t::is_accessible

前一篇Android system — 链接器命名空间（linker namespace）源码分析 介绍了dlopen时会通过is_accessible举行权限判断

1. // bionic/linker/linker_namespaces.cpp
2. // Given an absolute path, can this library be loaded into this namespace?
3. bool android_namespace_t::is_accessible(const std::string& file) {
4.   //判断命名空间的is_isolated_，即是否为严格隔离，如果不是则权限检查通过。
5.   if (!is_isolated_) {
6.     return true;
7.   }
8.   //判断是否在允许名单中
9.   if (!allowed_libs_.empty()) {
10.     const char *lib_name = basename(file.c_str());
11.     if (std::find(allowed_libs_.begin(), allowed_libs_.end(), lib_name) == allowed_libs_.end()) {
12.       return false;
13.     }
14.   }
15.   //判断是否在ld_library_paths中（LD_LIBRARY_PATH设置）
16.   for (const auto& dir : ld_library_paths_) {
17.     if (file_is_in_dir(file, dir)) {
18.       return true;
19.     }
20.   }
21.   //判断是否在default_library_paths中
22.   for (const auto& dir : default_library_paths_) {
23.     if (file_is_in_dir(file, dir)) {
24.       return true;
25.     }
26.   }
27.   //判断是否在特权路径permitted_paths中
28.   for (const auto& dir : permitted_paths_) {
29.     if (file_is_under_dir(file, dir)) {
30.       return true;
31.     }
32.   }
34.   return false;
35. }

复制代码

我们可以看到这里有个allowed_libs_，我们跟踪代码可以发现linker_namespaces.h中有set_allowed_libs接口

1. // bionic/linker/linker_namespaces.h
2.   const std::vector<std::string>& get_allowed_libs() const { return allowed_libs_; }
3.   void set_allowed_libs(std::vector<std::string>&& allowed_libs) {
4.     allowed_libs_ = std::move(allowed_libs);
5.   }
6.   void set_allowed_libs(const std::vector<std::string>& allowed_libs) {
7.     allowed_libs_ = allowed_libs;
8.   }

复制代码

2.1.2 init_default_namespaces

通过这个思路我们发现调用实在在init_default_namespaces

• 初始化default命名空间
  
• 初始化vndk等其他命名空间
  
• 在命名空间之间创建链接
  

1. std::vector<android_namespace_t*> init_default_namespaces(const char* executable_path) {
2.   g_default_namespace.set_name("(default)");
4.   soinfo* somain = solist_get_somain();
6.   const char *interp = phdr_table_get_interpreter_name(somain->phdr, somain->phnum,
7.                                                        somain->load_bias);
8.   const char* bname = (interp != nullptr) ? basename(interp) : nullptr;
10.   g_is_asan = bname != nullptr &&
11.               (strcmp(bname, "linker_asan") == 0 ||
12.                strcmp(bname, "linker_asan64") == 0);
14.   const Config* config = nullptr;
16.   {
17.     std::string ld_config_file_path = get_ld_config_file_path(executable_path);
18.     INFO("[ Reading linker config "%s" ]", ld_config_file_path.c_str());
19.     ScopedTrace trace(("linker config " + ld_config_file_path).c_str());
20.     std::string error_msg;
21.     if (!Config::read_binary_config(ld_config_file_path.c_str(), executable_path, g_is_asan,
22.                                     &config, &error_msg)) {
23.       if (!error_msg.empty()) {
24.         DL_WARN("Warning: couldn't read '%s' for '%s' (using default configuration instead): %s",
25.                 ld_config_file_path.c_str(), executable_path, error_msg.c_str());
26.       }
27.       config = nullptr;
28.     }
29.   }
31.   if (config == nullptr) {
32.     return init_default_namespace_no_config(g_is_asan);
33.   }
35.   const auto& namespace_configs = config->namespace_configs();
36.   std::unordered_map<std::string, android_namespace_t*> namespaces;
38.   // 1. Initialize default namespace
39.   const NamespaceConfig* default_ns_config = config->default_namespace_config();
41.   g_default_namespace.set_isolated(default_ns_config->isolated());
42.   g_default_namespace.set_default_library_paths(default_ns_config->search_paths());
43.   g_default_namespace.set_permitted_paths(default_ns_config->permitted_paths());
45.   namespaces[default_ns_config->name()] = &g_default_namespace;
46.   if (default_ns_config->visible()) {
47.     g_exported_namespaces[default_ns_config->name()] = &g_default_namespace;
48.   }
50.   // 2. Initialize other namespaces
52.   for (auto& ns_config : namespace_configs) {
53.     if (namespaces.find(ns_config->name()) != namespaces.end()) {
54.       continue;
55.     }
57.     android_namespace_t* ns = new (g_namespace_allocator.alloc()) android_namespace_t();
58.     ns->set_name(ns_config->name());
59.     ns->set_isolated(ns_config->isolated());
60.     ns->set_default_library_paths(ns_config->search_paths());
61.     ns->set_permitted_paths(ns_config->permitted_paths());
62.     ns->set_allowed_libs(ns_config->allowed_libs());
64.     namespaces[ns_config->name()] = ns;
65.     if (ns_config->visible()) {
66.       g_exported_namespaces[ns_config->name()] = ns;
67.     }
68.   }
70.   // 3. Establish links between namespaces
71.   for (auto& ns_config : namespace_configs) {
72.     auto it_from = namespaces.find(ns_config->name());
73.     CHECK(it_from != namespaces.end());
74.     android_namespace_t* namespace_from = it_from->second;
75.     for (const NamespaceLinkConfig& ns_link : ns_config->links()) {
76.       auto it_to = namespaces.find(ns_link.ns_name());
77.       CHECK(it_to != namespaces.end());
78.       android_namespace_t* namespace_to = it_to->second;
79.       if (ns_link.allow_all_shared_libs()) {
80.         link_namespaces_all_libs(namespace_from, namespace_to);
81.       } else {
82.         link_namespaces(namespace_from, namespace_to, ns_link.shared_libs().c_str());
83.       }
84.     }
85.   }
86.   // we can no longer rely on the fact that libdl.so is part of default namespace
87.   // this is why we want to add ld-android.so to all namespaces from ld.config.txt
88.   soinfo* ld_android_so = solist_get_head();
90.   // we also need vdso to be available for all namespaces (if present)
91.   soinfo* vdso = solist_get_vdso();
92.   for (auto it : namespaces) {
93.     if (it.second != &g_default_namespace) {
94.       it.second->add_soinfo(ld_android_so);
95.       if (vdso != nullptr) {
96.         it.second->add_soinfo(vdso);
97.       }
98.       // somain and ld_preloads are added to these namespaces after LD_PRELOAD libs are linked
99.     }
100.   }
102.   set_application_target_sdk_version(config->target_sdk_version());
104.   std::vector<android_namespace_t*> created_namespaces;
105.   created_namespaces.reserve(namespaces.size());
106.   for (const auto& kv : namespaces) {
107.     created_namespaces.push_back(kv.second);
108.   }
109.   return created_namespaces;
110. }
111. }

复制代码

这内里我们发现设置文件是通过读取设置文件举行设置的，设置文件ld_config_file_path在Android 11后便改为/linkerconfig/ld.config.txt

1. static const char* const kLdConfigArchFilePath = "/system/etc/ld.config." ABI_STRING ".txt";
3. static const char* const kLdConfigFilePath = "/system/etc/ld.config.txt";
4. static const char* const kLdConfigVndkLiteFilePath = "/system/etc/ld.config.vndk_lite.txt";
6. static const char* const kLdGeneratedConfigFilePath = "/linkerconfig/ld.config.txt";
8. static std::string get_ld_config_file_path(const char* executable_path) {
9. #ifdef USE_LD_CONFIG_FILE
10.   // This is a debugging/testing only feature. Must not be available on
11.   // production builds.
12.   const char* ld_config_file_env = getenv("LD_CONFIG_FILE");
13.   if (ld_config_file_env != nullptr && file_exists(ld_config_file_env)) {
14.     return ld_config_file_env;
15.   }
16. #endif
18.   std::string path = get_ld_config_file_apex_path(executable_path);
19.   if (!path.empty()) {
20.     if (file_exists(path.c_str())) {
21.       return path;
22.     }
23.     DL_WARN("Warning: couldn't read config file "%s" for "%s"",
24.             path.c_str(), executable_path);
25.   }
27.   path = kLdConfigArchFilePath;
28.   if (file_exists(path.c_str())) {
29.     return path;
30.   }
32.   if (file_exists(kLdGeneratedConfigFilePath)) {
33.     return kLdGeneratedConfigFilePath;
34.   }
36.   if (is_linker_config_expected(executable_path)) {
37.     DL_WARN("Warning: failed to find generated linker configuration from "%s"",
38.             kLdGeneratedConfigFilePath);
39.   }
41.   path = get_ld_config_file_vndk_path();
42.   if (file_exists(path.c_str())) {
43.     return path;
44.   }
46.   return kLdConfigFilePath;
47. }

复制代码

2.2 设置共享库位置

上一章我们提到了设置文件位置为/linkerconfig/ld.config.txt，
在Android 11以前ld.config.txt是通过静态文件设置的，而Android 11是改为linkerconfig动态生成
我们以一个vendor/bin下的native 步伐为例，要利用system/lib下的库
在Android system — Android链接器命名空间（Android 11后）中，我们提到了“目录-区段”映射属性dir.name，指向 [name] 区段所应用到的目录的路径，实在就是baseconfig.cc中定义的dirToSection

1. // system/linkerconfig/contents/configuration/baseconfig.cc
3. android::linkerconfig::modules::Configuration CreateBaseConfiguration(
4.     Context& ctx) {
5.   std::vector<Section> sections;
7.   ctx.SetCurrentLinkerConfigType(LinkerConfigType::Default);
9.   // Don't change the order here. The first pattern that matches with the
10.   // absolute path of an executable is selected.
11.   std::vector<DirToSection> dirToSection = {
12.       {"/system/bin/", "system"},
13.       {"/system/xbin/", "system"},
14.       {Var("SYSTEM_EXT") + "/bin/", "system"},
16.       // Processes from the product partition will have a separate section if
17.       // PRODUCT_PRODUCT_VNDK_VERSION is defined. Otherwise, they are run from
18.       // the "system" section.
19.       {Var("PRODUCT") + "/bin/", "product"},
21.       {"/odm/bin/", "vendor"},
22.       {"/vendor/bin/", "vendor"},
23.       {"/data/nativetest/odm", "vendor"},
24.       {"/data/nativetest64/odm", "vendor"},
25.       {"/data/benchmarktest/odm", "vendor"},
26.       {"/data/benchmarktest64/odm", "vendor"},
27.       {"/data/nativetest/vendor", "vendor"},
28.       {"/data/nativetest64/vendor", "vendor"},
29.       {"/data/benchmarktest/vendor", "vendor"},
30.       {"/data/benchmarktest64/vendor", "vendor"},
32.       {"/data/nativetest/unrestricted", "unrestricted"},
33.       {"/data/nativetest64/unrestricted", "unrestricted"},
35.       // Create isolated namespace for development purpose.
36.       // This isolates binary from the system so binaries and libraries from
37.       // this location can be separated from system libraries.
38.       {"/data/local/tmp/isolated", "isolated"},
40.       // Create directories under shell-writable /data/local/tests for
41.       // each namespace in order to run tests.
42.       {"/data/local/tests/product", "product"},
43.       {"/data/local/tests/system", "system"},
44.       {"/data/local/tests/unrestricted", "unrestricted"},
45.       {"/data/local/tests/vendor", "vendor"},
47.       // TODO(b/123864775): Ensure tests are run from one of the subdirectories
48.       // above.  Then clean this up.
49.       {"/data/local/tmp", "unrestricted"},
51.       {"/postinstall", "postinstall"},
52.       // Fallback entry to provide APEX namespace lookups for binaries anywhere
53.       // else. This must be last.
54.       {"/data", "system"},
55.       // TODO(b/168556887): Remove this when we have a dedicated section for
56.       // binaries in APKs
57.       {Var("PRODUCT") + "/app/", "system"},
58.   };
60.   sections.emplace_back(BuildSystemSection(ctx));
61.   if (ctx.IsVndkAvailable()) {
62.     sections.emplace_back(BuildVendorSection(ctx));
63.     if (android::linkerconfig::modules::IsProductVndkVersionDefined()) {
64.       sections.emplace_back(BuildProductSection(ctx));
65.     } else {
66.       RedirectSection(dirToSection, "product", "system");
67.     }
68.   } else {
69.     RemoveSection(dirToSection, "product");
70.     RemoveSection(dirToSection, "vendor");
71.   }
73.   sections.emplace_back(BuildUnrestrictedSection(ctx));
74.   sections.emplace_back(BuildPostInstallSection(ctx));
76.   sections.emplace_back(BuildIsolatedSection(ctx));
78.   return android::linkerconfig::modules::Configuration(std::move(sections),
79.                                                        dirToSection);
80. }

复制代码

由于我们是vendor/bin下面的步伐，以是可以看出来我们是vendor section，因此我们看BuildVendorSection即可。

1. // system/linkerconfig/contents/section/vendor.cc
3. Section BuildVendorSection(Context& ctx) {
4.   ctx.SetCurrentSection(SectionType::Vendor);
5.   std::vector<Namespace> namespaces;
7.   namespaces.emplace_back(BuildVendorDefaultNamespace(ctx));
8.   namespaces.emplace_back(BuildVndkNamespace(ctx, VndkUserPartition::Vendor));
9.   namespaces.emplace_back(BuildSystemNamespace(ctx));
10.   namespaces.emplace_back(BuildRsNamespace(ctx));
12.   if (android::linkerconfig::modules::IsVndkInSystemNamespace()) {
13.     namespaces.emplace_back(BuildVndkInSystemNamespace(ctx));
14.   }
16.   std::set<std::string> visible_apexes;
18.   // APEXes with public libs should be visible
19.   for (const auto& apex : ctx.GetApexModules()) {
20.     if (apex.public_libs.size() > 0) {
21.       visible_apexes.insert(apex.name);
22.     }
23.   }
25.   android::linkerconfig::modules::LibProviders libs_providers = {};
26.   if (ctx.IsVndkAvailable()) {
27.     libs_providers[":vndk"] = android::linkerconfig::modules::LibProvider{
28.         "vndk",
29.         std::bind(BuildVndkNamespace, ctx, VndkUserPartition::Vendor),
30.         {Var("VNDK_SAMEPROCESS_LIBRARIES_VENDOR"),
31.          Var("VNDK_CORE_LIBRARIES_VENDOR")},
32.     };
33.   }
35.   return BuildSection(
36.       ctx, "vendor", std::move(namespaces), visible_apexes, libs_providers);
37. }

复制代码

我们可以看到末了调用了BuildSection，在此中调用了AddStandardSystemLinks 添加system的共享库

1. // system/linkerconfig/contents/section/sectionbuilder.cc
3. Section BuildSection(const Context& ctx, const std::string& name,
4.                      std::vector<Namespace>&& namespaces,
5.                      const std::set<std::string>& visible_apexes,
6.                      const LibProviders& providers) {
7.   // add additional visible APEX namespaces
8.   for (const auto& apex : ctx.GetApexModules()) {
9.     if (visible_apexes.find(apex.name) == visible_apexes.end() &&
10.         !apex.visible) {
11.       continue;
12.     }
13.     if (auto it = std::find_if(
14.             namespaces.begin(),
15.             namespaces.end(),
16.             [&apex](auto& ns) { return ns.GetName() == apex.namespace_name; });
17.         it == namespaces.end()) {
18.       auto ns = ctx.BuildApexNamespace(apex, true);
19.       namespaces.push_back(std::move(ns));
20.     } else {
21.       // override "visible" when the apex is already created
22.       it->SetVisible(true);
23.     }
24.   }
26.   // resolve provide/require constraints
27.   Section section(std::move(name), std::move(namespaces));
28.   if (auto res = section.Resolve(ctx, providers); !res.ok()) {
29.     LOG(ERROR) << res.error();
30.   }
32.   AddStandardSystemLinks(ctx, &section); // 添加通用的system link共享库
33.   return section;
34. }

复制代码

在kBionicLibs 加上我们必要的库即可

1. // system/linkerconfig/contents/common/system_links.cc
3. namespace {
4. const std::vector<std::string> kBionicLibs = {
5.     "libc.so",
6.     "libdl.so",
7.     "libdl_android.so",
8.     "libm.so",
9. };
10. }  // namespace
12. namespace android {
13. namespace linkerconfig {
14. namespace contents {
16. using android::linkerconfig::modules::Namespace;
17. using android::linkerconfig::modules::Section;
19. void AddStandardSystemLinks(const Context& ctx, Section* section) {
20.   const bool debuggable = android::base::GetBoolProperty("ro.debuggable", false);
21.   const std::string system_ns_name = ctx.GetSystemNamespaceName();
22.   const bool is_section_vndk_enabled = ctx.IsSectionVndkEnabled();
23.   section->ForEachNamespaces([&](Namespace& ns) {
24.     if (ns.GetName() != system_ns_name) {
25.       ns.GetLink(system_ns_name).AddSharedLib(kBionicLibs);
26.       if (!is_section_vndk_enabled || ns.GetName() != "default") {
27.         // TODO(b/185199923) remove the default value
28.         ns.GetLink(system_ns_name)
29.             .AddSharedLib(Var("SANITIZER_RUNTIME_LIBRARIES", ""));
30.       }
31.       if (debuggable) {
32.         // Library on the system image that can be dlopened for debugging purposes.
33.         ns.GetLink(system_ns_name).AddSharedLib("libfdtrack.so");
34.       }
35.     }
36.   });
37. }
39. }  // namespace contents
40. }  // namespace linkerconfig
41. }  // namespace android

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。