feat: optimize soinfo set/get functions, symbol lookup and implement so relocation

Author: sanfengAndroid

library/src/main/cpp/include/fake_linker.h

@@ -267,7 +267,7 @@ typedef struct {
   FunPtr(SymbolAddress *, soinfo_get_import_symbol_address, SoinfoPtr soinfo_ptr, const char *name, int *out_error);
 
   /**
-   * @briefSpecify the soinfo pointer to get the export symbol address of the
+   * @brief Specify the soinfo pointer to get the export symbol address of the
    * specified name
    *
    * @param       soinfo_ptr  Specify the soinfo pointer
@@ -414,11 +414,22 @@ typedef struct {
    */
   FunPtr(bool, call_manual_relocation_by_names, SoinfoPtr global_lib, int len, const char *target_names[]);
 
+  /**
+   * @brief Specify the soinfo pointer to get the first export symbol address of the
+   * specified name prefix
+   *
+   * @param       soinfo_ptr  Specify the soinfo pointer
+   * @param       name        Export symbol name
+   * @param[out]  out_error   Write error code on error exists
+   * @return Symbolic address or nullptr
+   */
+  FunPtr(SymbolAddress, soinfo_get_export_symbol_address_by_prefix, SoinfoPtr soinfo_ptr, const char *name,
+         int *out_error);
+
   /**
    * @brief New version expansion reserved slot
    *
    */
-  FunPtr(void, unused0);
   FunPtr(void, unused1);
   FunPtr(void, unused2);
   FunPtr(void, unused3);
@@ -816,10 +827,21 @@ typedef struct {
    * LINKER_VERBOSITY_TRACE 1
    * LINKER_VERBOSITY_DEBUG 2
    *
+   * Android 15+ new debug config
+   * calls   : 1 << 0
+   * cfi     : 1 << 1
+   * dynamic : 1 << 2
+   * lookup  : 1 << 3
+   * reloc   : 1 << 4
+   * props   : 1 << 5
+   *
    * @param  level   log level, the larger the value, the more logs
    */
   FunPtr(bool, set_ld_debug_verbosity, int level);
 
+  FunPtr(uint64_t, find_library_symbol_by_prefix, const char *library_name, const char *symbol_name,
+         const FindSymbolType symbol_type);
+
 } FakeLinker;
 
 #undef FunPtr
@@ -836,23 +858,50 @@ extern void fakelinker_module_init(JNIEnv *env, SoinfoPtr fake_soinfo, const Fak
 
 enum FakeLinkerMode {
   /**
-   * Initialize soinfo, namespace feature
+   * Initialize soinfo, initialize all linker functions by default,
+   * if only some functions are needed, please add kInitLinkerXXXX flag
    */
   kFMSoinfo = 1,
   /**
    * Initialize android native hook feature
    */
-  kFMNativeHook = 2,
+  kFMNativeHook = 1 << 1,
 
   /**
    * Register the Java functions, by default, the FakeLinker class will return success even if the registration fails,
    * whereas non-default classes will only return success if the registration is successful.
    */
-  kFMJavaRegister = 4,
+  kFMJavaRegister = 1 << 2,
   /**
    * The default FakeLinker class or non-default classes must return success only if the registration is successful.
    */
-  kFMForceJavaRegister = 8,
+  kFMForceJavaRegister = 1 << 3,
+  /**
+   * Initialize only linker debug symbols
+   *
+   */
+  kInitLinkerDebug = 1 << 4,
+  /**
+   * Initialize only linker dlopen/dlsym to use symbols
+   *
+   */
+  kInitLinkerDlopenDlSym = 1 << 5,
+  /**
+   * Initialize only linker namespace symbols
+   *
+   */
+  kInitLinkerNamespace = 1 << 6,
+  /**
+   * Initialize only linker handler symbols
+   *
+   */
+  kInitLinkerHandler = 1 << 7,
+  /**
+   * Initialize only linker memory symbols
+   *
+   */
+  kInitLinkerMemory = 1 << 8,
+
 };
 
 /**

library/src/main/cpp/include/linker_macros.h

@@ -17,6 +17,8 @@
 #define ANDROID_GE_V
 #define ANDROID_LE_M
 #define ANDROID_LE_L1
+#define ANDROID_LE_N1
+#define ANDROID_LE_O
 #define ANDROID_LE_O1
 #define ANDROID_LE_S
 #define ANDROID_LE_U

library/src/main/cpp/include/scoped_local_ref.h

@@ -52,6 +52,8 @@ class ScopedLocalRef {
 
   T get() const { return mLocalRef; }
 
+  operator bool() const { return mLocalRef != nullptr; }
+
 private:
   JNIEnv *const mEnv;
   T mLocalRef;

library/src/main/cpp/include/type.h

@@ -10,13 +10,18 @@ struct return_type_trait<Return (*)(Args...)> {
   using type = Return;
 };
 
+template <typename P>
+using return_type_trait_t = typename return_type_trait<P>::type;
+
 template <typename P>
 struct return_type_object_trait;
 
 template <typename Object, typename Return, typename... Args>
 struct return_type_object_trait<Return (Object::*)(Args...)> {
   using type = Return;
 };
+template <typename P>
+using return_type_object_trait_t = typename return_type_object_trait<P>::type;
 
 template <typename P>
 struct member_type_trait;
@@ -36,10 +41,27 @@ struct member_type_trait<const char (Object::*)[N]> {
   using type = const char *;
 };
 
+template <typename P>
+using member_type_trait_t = typename member_type_trait<P>::type;
+
 template <typename P>
 struct member_ref_type_trait;
 
 template <typename Type, typename Object>
 struct member_ref_type_trait<Type Object::*> {
-  using type = typename std::add_lvalue_reference<Type>::type;
+  using type = typename std::add_lvalue_reference_t<Type>;
+};
+
+template <typename P>
+using member_ref_type_trait_t = typename member_ref_type_trait<P>::type;
+
+template <typename P>
+struct const_member_ref_type_trait;
+
+template <typename Type, typename Object>
+struct const_member_ref_type_trait<Type Object::*> {
+  using type = std::add_lvalue_reference_t<std::add_const_t<Type>>;
 };
+
+template <typename P>
+using const_member_ref_type_trait_t = typename const_member_ref_type_trait<P>::type;

library/src/main/cpp/linker/linker_export.cpp

@@ -216,6 +216,17 @@ static SymbolAddress soinfo_get_export_symbol_address_impl(SoinfoPtr soinfo_ptr,
   CHECK_PARAM_PTR(soinfo_ptr, kErrorSoinfoNull);
   CHECK_PARAM_PTR(name, kErrorParameterNull);
   auto *info = static_cast<soinfo *>(soinfo_ptr);
+  void *result = info->find_export_symbol_by_prefix(name);
+  CHECK_ERROR(result, kErrorSymbolNotFoundInSoinfo);
+  return result;
+}
+
+static SymbolAddress soinfo_get_export_symbol_address_prefix_impl(SoinfoPtr soinfo_ptr, const char *name,
+                                                                  int *out_error) {
+  RET_SUCCESS();
+  CHECK_PARAM_PTR(soinfo_ptr, kErrorSoinfoNull);
+  CHECK_PARAM_PTR(name, kErrorParameterNull);
+  auto *info = static_cast<soinfo *>(soinfo_ptr);
   void *result = info->find_export_symbol_address(name);
   CHECK_ERROR(result, kErrorSymbolNotFoundInSoinfo);
   return result;
@@ -681,6 +692,7 @@ static uint64_t find_library_symbol_impl(const char *library_name, const char *s
   return 0;
 }
 
+
 static MEMORY_FREE uint64_t *find_library_symbols_impl(const char *library_name, const FindSymbolUnit *symbols,
                                                        int size) {
   if (!library_name || !symbols || size < 1) {
@@ -780,7 +792,7 @@ C_API API_PUBLIC FakeLinker g_fakelinker_export = {
   call_manual_relocation_by_soinfos_impl,
   call_manual_relocation_by_name_impl,
   call_manual_relocation_by_names_impl,
-  nullptr, /* unused0 */
+  soinfo_get_export_symbol_address_prefix_impl,
   nullptr, /* unused1 */
   nullptr, /* unused2 */
   nullptr, /* unused3 */
@@ -841,6 +853,7 @@ C_API API_PUBLIC FakeLinker g_fakelinker_export = {
   find_library_symbol_impl,
   find_library_symbols_impl,
   set_ld_debug_verbosity_impl,
+  nullptr,
 };
 
 C_API const FakeLinker *get_fakelinker() { return &g_fakelinker_export; }

library/src/main/cpp/linker/linker_globals.cpp

@@ -168,7 +168,7 @@ void ProxyLinker::ChangeSoinfoOfNamespace(soinfo *so, android_namespace_t *np) {
   }
   LinkerBlockLock lock;
   so->get_primary_namespace()->remove_soinfo(so);
-  so->get_primary_namespace() = np;
+  so->set_primary_namespace(np);
   np->add_soinfo(so);
 }
 
@@ -183,7 +183,7 @@ void ProxyLinker::AddSoinfoToDefaultNamespace(soinfo *si) {
   for (auto &np : ProxyLinker::GetAllNamespace(true)) {
     if (strcmp(np->get_name(), DEFAULT_NAMESPACE_NAME) == 0) {
       si->get_primary_namespace()->remove_soinfo(si);
-      si->get_primary_namespace() = np;
+      si->set_primary_namespace(np);
       np->add_soinfo(si);
       break;
     }
@@ -546,7 +546,13 @@ bool ProxyLinker::SetLdDebugVerbosity(int level) {
     *p = level;
     return true;
   } else if (auto *config = linker_symbol.g_linker_debug_config.Get()) {
-    config->any = true;
+    config->calls = level & 1;
+    config->cfi = level & (1 << 1);
+    config->dynamic = level & (1 << 2);
+    config->lookup = level & (1 << 3);
+    config->reloc = level & (1 << 4);
+    config->props = level & (1 << 5);
+    config->any = level & (0b111111);
     return true;
   }
   return false;
@@ -659,7 +665,7 @@ bool ProxyLinker::ManualRelinkLibraries(soinfo *global, const std::vector<std::s
   if (__predict_false(global == nullptr) || __predict_false(sonames.empty())) {
     return false;
   }
-  symbol_relocations rels = global->get_global_soinfo_export_symbols(filters);
+  symbol_relocations rels = global->get_global_soinfo_export_symbols(false, filters);
   if (rels.empty()) {
     LOGW("Function symbols not exported by the global library : %s",
          global->get_soname() == nullptr ? "(null)" : global->get_soname());
@@ -682,7 +688,7 @@ bool ProxyLinker::ManualRelinkLibraries(soinfo *global, int len, const std::vect
   if (__predict_false(global == nullptr) || __predict_false(targets.empty())) {
     return false;
   }
-  symbol_relocations rels = global->get_global_soinfo_export_symbols(filters);
+  symbol_relocations rels = global->get_global_soinfo_export_symbols(false, filters);
   if (rels.empty()) {
     LOGW("Function symbols not exported by the global library : %s",
          global->get_soname() == nullptr ? "(null)" : global->get_soname());
@@ -704,7 +710,7 @@ bool ProxyLinker::ManualRelinkLibrary(soinfo *global, soinfo *child, std::vector
   if (__predict_false(global == nullptr)) {
     return false;
   }
-  symbol_relocations rels = global->get_global_soinfo_export_symbols(filters);
+  symbol_relocations rels = global->get_global_soinfo_export_symbols(false, filters);
   if (rels.empty()) {
     LOGW("Function symbols not exported by the global library : %s",
          global->get_soname() == nullptr ? "(null)" : global->get_soname());

library/src/main/cpp/linker/linker_globals.h

@@ -127,11 +127,11 @@ class ProxyLinker {
 
   bool SystemRelinkLibraries(const std::vector<std::string> &sonames);
 
+  soinfo_list_t GetSoinfoGlobalGroup(soinfo *root);
+
 private:
   ANDROID_LE_M soinfo_list_t GetGlobalGroupM();
 
-  soinfo_list_t GetSoinfoGlobalGroup(soinfo *root);
-
   ANDROID_GE_M bool RelinkSoinfoImplM(soinfo *si);
 
   ANDROID_LE_L1 bool RelinkSoinfoImplL(soinfo *si);

library/src/main/cpp/linker/linker_main.cpp

@@ -24,15 +24,14 @@ bool init_success = false;
 
 using FakeLinkerModulePtr = void (*)(JNIEnv *, SoinfoPtr, const FakeLinker *);
 
-static void Init() {
+static void Init(fakelinker::LinkerSymbolCategory category) {
   static bool initialized = false;
   if (!initialized) {
     soinfo::Init();
     android_namespace_t::Init();
-    fakelinker::linker_symbol.InitSymbolName();
   }
   if (!init_success) {
-    init_success = fakelinker::linker_symbol.LoadSymbol();
+    init_success = fakelinker::linker_symbol.LoadSymbol(category);
   }
   initialized = true;
 }
@@ -133,7 +132,30 @@ C_API int init_fakelinker(JNIEnv *env, FakeLinkerMode mode, const char *java_cla
   static bool native_hook_initialized = false;
   static bool java_register_initialized = false;
   if (mode & FakeLinkerMode::kFMSoinfo) {
-    Init();
+    int symbol_type = fakelinker::LinkerSymbolCategory::kLinkerAll;
+    if (mode &
+        (FakeLinkerMode::kInitLinkerDebug | FakeLinkerMode::kInitLinkerDlopenDlSym |
+         FakeLinkerMode::kInitLinkerNamespace | FakeLinkerMode::kInitLinkerHandler |
+         FakeLinkerMode::kInitLinkerMemory)) {
+      symbol_type = 0;
+      if (mode & FakeLinkerMode::kInitLinkerDebug) {
+        symbol_type |= fakelinker::LinkerSymbolCategory::kLinkerDebug;
+      }
+      if (mode & FakeLinkerMode::kInitLinkerDlopenDlSym) {
+        symbol_type |= fakelinker::LinkerSymbolCategory::kDlopenDlSym;
+      }
+      if (mode & FakeLinkerMode::kInitLinkerNamespace) {
+        symbol_type |= fakelinker::LinkerSymbolCategory::kNamespace;
+      }
+      if (mode & FakeLinkerMode::kInitLinkerHandler) {
+        symbol_type |= fakelinker::LinkerSymbolCategory::kSoinfoHandler;
+      }
+      if (mode & FakeLinkerMode::kInitLinkerMemory) {
+        symbol_type |= fakelinker::LinkerSymbolCategory::kSoinfoMemory;
+      }
+    }
+
+    Init(static_cast<fakelinker::LinkerSymbolCategory>(symbol_type));
     if (!init_success) {
       return 1;
     }