重读Linker#

1
public static void load(String filename) {
2
        Runtime.getRuntime().load0(Reflection.getCallerClass(), filename);
3
    }

1
synchronized void load0(Class<?> fromClass, String filename) {
2
        File file = new File(filename);
3
        if (!(file.isAbsolute())) {
4
            throw new UnsatisfiedLinkError(
5
                "Expecting an absolute path of the library: " + filename);
6
        }
7
        if (filename == null) {
8
            throw new NullPointerException("filename == null");
9
        }
10
        if (Flags.readOnlyDynamicCodeLoad()) {
11
            if (!file.toPath().getFileSystem().isReadOnly() && file.canWrite()) {
12
                if (VMRuntime.getSdkVersion() >= VersionCodes.VANILLA_ICE_CREAM) {
13
                    System.logW("Attempt to load writable file: " + filename
14
                            + ". This will throw on a future Android version");
15
                }
16
            }
17
        }
18
        // 就这一句有用，其他可以暂时不看
19
        String error = nativeLoad(filename, fromClass.getClassLoader(), fromClass);
20
        if (error != null) {
21
            throw new UnsatisfiedLinkError(error);
22
        }
23
    }

1
// This method is used through reflection from /art/test/150-loadlibrary.
2
    private static String nativeLoad(String filename, ClassLoader loader) {
3
        return nativeLoad(filename, loader, null);
4
    }
5

6
    private static native String nativeLoad(String filename, ClassLoader loader, Class<?> caller);

1
JNIEXPORT jstring JNICALL
2
Runtime_nativeLoad(JNIEnv* env, jclass ignored, jstring javaFilename,
3
                   jobject javaLoader, jclass caller)
4
{
5
    return JVM_NativeLoad(env, javaFilename, javaLoader, caller);
6
}

1
JNIEXPORT jstring JVM_NativeLoad(JNIEnv* env,
2
                                 jstring javaFilename,
3
                                 jobject javaLoader,
4
                                 jclass caller) {
5
  ScopedUtfChars filename(env, javaFilename);
6
  if (filename.c_str() == nullptr) {
7
    return nullptr;
8
  }
9

10
  std::string error_msg;
11
  {
12
    art::JavaVMExt* vm = art::Runtime::Current()->GetJavaVM();
13
    bool success = vm->LoadNativeLibrary(env,
14
                                         filename.c_str(),
15
                                         javaLoader,
16
                                         caller,
17
                                         &error_msg);
18
    if (success) {
19
      return nullptr;
20
    }
21
  }
22

23
  // Don't let a pending exception from JNI_OnLoad cause a CheckJNI issue with NewStringUTF.
24
  env->ExceptionClear();
25
  return env->NewStringUTF(error_msg.c_str());
26
}

1
bool JavaVMExt::LoadNativeLibrary(JNIEnv* env,
2
                                  const std::string& path,
3
                                  jobject class_loader,
4
                                  jclass caller_class,
5
                                  std::string* error_msg) {
6
  error_msg->clear();
7

8
  // See if we've already loaded this library.  If we have, and the class loader
9
  // matches, return successfully without doing anything.
10
  // TODO: for better results we should canonicalize the pathname (or even compare
11
  // inodes). This implementation is fine if everybody is using System.loadLibrary.
12
  SharedLibrary* library;
13
  Thread* self = Thread::Current();
14
  {
15
    // TODO: move the locking (and more of this logic) into Libraries.
16
    MutexLock mu(self, *Locks::jni_libraries_lock_);
17
    library = libraries_->Get(path);
18
  }
19
  void* class_loader_allocator = nullptr;
20
  std::string caller_location;
21
  {
22
    ScopedObjectAccess soa(env);
23
    // As the incoming class loader is reachable/alive during the call of this function,
24
    // it's okay to decode it without worrying about unexpectedly marking it alive.
25
    ObjPtr<mirror::ClassLoader> loader = soa.Decode<mirror::ClassLoader>(class_loader);
26

27
    ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
28
    if (class_linker->IsBootClassLoader(loader)) {
29
      loader = nullptr;
30
      class_loader = nullptr;
31
    }
32
    if (caller_class != nullptr) {
33
      ObjPtr<mirror::Class> caller = soa.Decode<mirror::Class>(caller_class);
34
      ObjPtr<mirror::DexCache> dex_cache = caller->GetDexCache();
35
      if (dex_cache != nullptr) {
36
        caller_location = dex_cache->GetLocation()->ToModifiedUtf8();
37
      }
38
    }
39

40
    class_loader_allocator = class_linker->GetAllocatorForClassLoader(loader);
41
    CHECK(class_loader_allocator != nullptr);
42
  }
43
  if (library != nullptr) {
44
    // Use the allocator pointers for class loader equality to avoid unnecessary weak root decode.
45
    if (library->GetClassLoaderAllocator() != class_loader_allocator) {
46
      // The library will be associated with class_loader. The JNI
47
      // spec says we can't load the same library into more than one
48
      // class loader.
49
      //
50
      // This isn't very common. So spend some time to get a readable message.
51
      auto call_to_string = [&](jobject obj) -> std::string {
52
        if (obj == nullptr) {
53
          return "null";
54
        }
55
        // Handle jweaks. Ignore double local-ref.
56
        ScopedLocalRef<jobject> local_ref(env, env->NewLocalRef(obj));
57
        if (local_ref != nullptr) {
58
          ScopedLocalRef<jclass> local_class(env, env->GetObjectClass(local_ref.get()));
59
          jmethodID to_string = env->GetMethodID(local_class.get(),
60
                                                 "toString",
61
                                                 "()Ljava/lang/String;");
62
          DCHECK(to_string != nullptr);
63
          ScopedLocalRef<jobject> local_string(env,
64
                                               env->CallObjectMethod(local_ref.get(), to_string));
65
          if (local_string != nullptr) {
66
            ScopedUtfChars utf(env, reinterpret_cast<jstring>(local_string.get()));
67
            if (utf.c_str() != nullptr) {
68
              return utf.c_str();
69
            }
70
          }
71
          if (env->ExceptionCheck()) {
72
            // We can't do much better logging, really. So leave it with a Describe.
73
            env->ExceptionDescribe();
74
            env->ExceptionClear();
75
          }
76
          return "(Error calling toString)";
77
        }
78
        return "null";
79
      };
80
      std::string old_class_loader = call_to_string(library->GetClassLoader());
81
      std::string new_class_loader = call_to_string(class_loader);
82
      StringAppendF(error_msg, "Shared library \"%s\" already opened by "
83
          "ClassLoader %p(%s); can't open in ClassLoader %p(%s)",
84
          path.c_str(),
85
          library->GetClassLoader(),
86
          old_class_loader.c_str(),
87
          class_loader,
88
          new_class_loader.c_str());
89
      LOG(WARNING) << *error_msg;
90
      return false;
91
    }
92
    VLOG(jni) << "[Shared library \"" << path << "\" already loaded in "
93
              << " ClassLoader " << class_loader << "]";
94
    if (!library->CheckOnLoadResult()) {
95
      StringAppendF(error_msg, "JNI_OnLoad failed on a previous attempt "
96
          "to load \"%s\"", path.c_str());
97
      return false;
98
    }
99
    return true;
100
  }
101

102
  // Open the shared library.  Because we're using a full path, the system
103
  // doesn't have to search through LD_LIBRARY_PATH.  (It may do so to
104
  // resolve this library's dependencies though.)
105

106
  // Failures here are expected when java.library.path has several entries
107
  // and we have to hunt for the lib.
108

109
  // Below we dlopen but there is no paired dlclose, this would be necessary if we supported
110
  // class unloading. Libraries will only be unloaded when the reference count (incremented by
111
  // dlopen) becomes zero from dlclose.
112

113
  // Retrieve the library path from the classloader, if necessary.
114
  ScopedLocalRef<jstring> library_path(env, GetLibrarySearchPath(env, class_loader));
115

116
  Locks::mutator_lock_->AssertNotHeld(self);
117
  const char* path_str = path.empty() ? nullptr : path.c_str();
118
  bool needs_native_bridge = false;
119
  char* nativeloader_error_msg = nullptr;
120
  void* handle = android::OpenNativeLibrary(
121
      env,
122
      runtime_->GetTargetSdkVersion(),
123
      path_str,
124
      class_loader,
125
      (caller_location.empty() ? nullptr : caller_location.c_str()),
126
      library_path.get(),
127
      &needs_native_bridge,
128
      &nativeloader_error_msg);
129
  VLOG(jni) << "[Call to dlopen(\"" << path << "\", RTLD_NOW) returned " << handle << "]";
130

131
  if (handle == nullptr) {
132
    *error_msg = nativeloader_error_msg;
133
    android::NativeLoaderFreeErrorMessage(nativeloader_error_msg);
134
    VLOG(jni) << "dlopen(\"" << path << "\", RTLD_NOW) failed: " << *error_msg;
135
    return false;
136
  }
137

138
  if (env->ExceptionCheck() == JNI_TRUE) {
139
    LOG(ERROR) << "Unexpected exception:";
140
    env->ExceptionDescribe();
141
    env->ExceptionClear();
142
  }
143
  // Create a new entry.
144
  // TODO: move the locking (and more of this logic) into Libraries.
145
  bool created_library = false;
146
  {
147
    // Create SharedLibrary ahead of taking the libraries lock to maintain lock ordering.
148
    std::unique_ptr<SharedLibrary> new_library(
149
        new SharedLibrary(env,
150
                          self,
151
                          path,
152
                          handle,
153
                          needs_native_bridge,
154
                          class_loader,
155
                          class_loader_allocator));
156

157
    MutexLock mu(self, *Locks::jni_libraries_lock_);
158
    library = libraries_->Get(path);
159
    if (library == nullptr) {  // We won race to get libraries_lock.
160
      library = new_library.release();
161
      libraries_->Put(path, library);
162
      created_library = true;
163
    }
164
  }
165
  if (!created_library) {
166
    LOG(INFO) << "WOW: we lost a race to add shared library: "
167
        << "\"" << path << "\" ClassLoader=" << class_loader;
168
    return library->CheckOnLoadResult();
169
  }
170
  VLOG(jni) << "[Added shared library \"" << path << "\" for ClassLoader " << class_loader << "]";
171

172
  bool was_successful = false;
173
  void* sym = library->FindSymbol("JNI_OnLoad", nullptr, android::kJNICallTypeRegular);
174
  if (sym == nullptr) {
175
    VLOG(jni) << "[No JNI_OnLoad found in \"" << path << "\"]";
176
    was_successful = true;
177
  } else {
178
    // Call JNI_OnLoad.  We have to override the current class
179
    // loader, which will always be "null" since the stuff at the
180
    // top of the stack is around Runtime.loadLibrary().  (See
181
    // the comments in the JNI FindClass function.)
182
    ScopedLocalRef<jobject> old_class_loader(env, env->NewLocalRef(self->GetClassLoaderOverride()));
183
    self->SetClassLoaderOverride(class_loader);
184

185
    VLOG(jni) << "[Calling JNI_OnLoad in \"" << path << "\"]";
186
    using JNI_OnLoadFn = int(*)(JavaVM*, void*);
187
    JNI_OnLoadFn jni_on_load = reinterpret_cast<JNI_OnLoadFn>(sym);
188
    int version = (*jni_on_load)(this, nullptr);
189

190
    if (IsSdkVersionSetAndAtMost(runtime_->GetTargetSdkVersion(), SdkVersion::kL)) {
191
      // Make sure that sigchain owns SIGSEGV.
192
      EnsureFrontOfChain(SIGSEGV);
193
    }
194

195
    self->SetClassLoaderOverride(old_class_loader.get());
196

197
    if (version == JNI_ERR) {
198
      StringAppendF(error_msg, "JNI_ERR returned from JNI_OnLoad in \"%s\"", path.c_str());
199
    } else if (JavaVMExt::IsBadJniVersion(version)) {
200
      StringAppendF(error_msg, "Bad JNI version returned from JNI_OnLoad in \"%s\": %d",
201
                    path.c_str(), version);
202
      // It's unwise to call dlclose() here, but we can mark it
203
      // as bad and ensure that future load attempts will fail.
204
      // We don't know how far JNI_OnLoad got, so there could
205
      // be some partially-initialized stuff accessible through
206
      // newly-registered native method calls.  We could try to
207
      // unregister them, but that doesn't seem worthwhile.
208
    } else {
209
      was_successful = true;
210
    }
211
    VLOG(jni) << "[Returned " << (was_successful ? "successfully" : "failure")
212
              << " from JNI_OnLoad in \"" << path << "\"]";
213
  }
214

215
  library->SetResult(was_successful);
216
  return was_successful;
217
}

1
void* OpenNativeLibrary(JNIEnv* env,
2
                        int32_t target_sdk_version,
3
                        const char* path,
4
                        jobject class_loader,
5
                        const char* caller_location,
6
                        jstring library_path_j,
7
                        bool* needs_native_bridge,
8
                        char** error_msg) {
9
#if defined(ART_TARGET_ANDROID)
10
  if (class_loader == nullptr) {
11
    // class_loader is null only for the boot class loader (see
12
    // IsBootClassLoader call in JavaVMExt::LoadNativeLibrary), i.e. the caller
13
    // is in the boot classpath.
14
    *needs_native_bridge = false;
15
    if (caller_location != nullptr) {
16
      std::optional<NativeLoaderNamespace> ns = FindApexNamespace(caller_location);
17
      if (ns.has_value()) {
18
        const android_dlextinfo dlextinfo = {
19
            .flags = ANDROID_DLEXT_USE_NAMESPACE,
20
            .library_namespace = ns.value().ToRawAndroidNamespace(),
21
        };
22
        void* handle = android_dlopen_ext(path, RTLD_NOW, &dlextinfo);
23
        char* dlerror_msg = handle == nullptr ? strdup(dlerror()) : nullptr;
24
        ALOGD("Load %s using APEX ns %s for caller %s: %s",
25
              path,
26
              ns.value().name().c_str(),
27
              caller_location,
28
              dlerror_msg == nullptr ? "ok" : dlerror_msg);
29
        if (dlerror_msg != nullptr) {
30
          *error_msg = dlerror_msg;
31
        }
32
        return handle;
33
      }
34
    }
35

36
    // Check if the library is in NATIVELOADER_DEFAULT_NAMESPACE_LIBS and should
37
    // be loaded from the kNativeloaderExtraLibs namespace.
38
    {
39
      Result<void*> handle = TryLoadNativeloaderExtraLib(path);
40
      if (!handle.ok()) {
41
        *error_msg = strdup(handle.error().message().c_str());
42
        return nullptr;
43
      }
44
      if (handle.value() != nullptr) {
45
        return handle.value();
46
      }
47
    }
48

49
    // Handle issue b/349878424.
50
    static bool bypass_loading_for_b349878424 = ShouldBypassLoadingForB349878424();
51

52
    if (bypass_loading_for_b349878424 &&
53
        (strcmp("libsobridge.so", path) == 0 || strcmp("libwalkstack.so", path) == 0)) {
54
      // Load a different library to pretend the loading was successful. This
55
      // allows the device to boot.
56
      ALOGD("Loading libbase.so instead of %s due to b/349878424", path);
57
      path = "libbase.so";
58
    }
59

60
    // Fall back to the system namespace. This happens for preloaded JNI
61
    // libraries in the zygote.
62
    void* handle = OpenSystemLibrary(path, RTLD_NOW);
63
    char* dlerror_msg = handle == nullptr ? strdup(dlerror()) : nullptr;
64
    ALOGD("Load %s using system ns (caller=%s): %s",
65
          path,
66
          caller_location == nullptr ? "<unknown>" : caller_location,
67
          dlerror_msg == nullptr ? "ok" : dlerror_msg);
68
    if (dlerror_msg != nullptr) {
69
      *error_msg = dlerror_msg;
70
    }
71
    return handle;
72
  }
73

74
  // If the caller is in any of the system image partitions and the library is
75
  // in the same partition then load it without regards to public library
76
  // restrictions. This is only done if the library is specified by an absolute
77
  // path, so we don't affect the lookup process for libraries specified by name
78
  // only.
79
  if (caller_location != nullptr &&
80
      // Apps in the partition may have their own native libraries which should
81
      // be loaded with the app's classloader namespace, so only do this for
82
      // libraries in the partition-wide lib(64) directories.
83
      nativeloader::IsPartitionNativeLibPath(path) &&
84
      // Don't do this if the system image is older than V, to avoid any compat
85
      // issues with apps and shared libs in them.
86
      android::modules::sdklevel::IsAtLeastV()) {
87
    nativeloader::ApiDomain caller_api_domain = nativeloader::GetApiDomainFromPath(caller_location);
88
    if (caller_api_domain != nativeloader::API_DOMAIN_DEFAULT) {
89
      nativeloader::ApiDomain library_api_domain = nativeloader::GetApiDomainFromPath(path);
90

91
      if (library_api_domain == caller_api_domain) {
92
        bool is_bridged = false;
93
        if (library_path_j != nullptr) {
94
          ScopedUtfChars library_path_utf_chars(env, library_path_j);
95
          if (library_path_utf_chars[0] != '\0') {
96
            is_bridged = NativeBridgeIsPathSupported(library_path_utf_chars.c_str());
97
          }
98
        }
99

100
        Result<NativeLoaderNamespace> ns = GetNamespaceForApiDomain(caller_api_domain, is_bridged);
101
        if (!ns.ok()) {
102
          ALOGD("Failed to find ns for caller %s in API domain %d to load %s (is_bridged=%b): %s",
103
                caller_location,
104
                caller_api_domain,
105
                path,
106
                is_bridged,
107
                ns.error().message().c_str());
108
          *error_msg = strdup(ns.error().message().c_str());
109
          return nullptr;
110
        }
111

112
        *needs_native_bridge = ns.value().IsBridged();
113
        Result<void*> handle = ns.value().Load(path);
114
        ALOGD("Load %s using ns %s for caller %s in same partition (is_bridged=%b): %s",
115
              path,
116
              ns.value().name().c_str(),
117
              caller_location,
118
              is_bridged,
119
              handle.ok() ? "ok" : handle.error().message().c_str());
120
        if (!handle.ok()) {
121
          *error_msg = strdup(handle.error().message().c_str());
122
          return nullptr;
123
        }
124
        return handle.value();
125
      }
126
    }
127
  }
128

129
  NativeLoaderNamespace* ns;
130
  const char* ns_descr;
131
  {
132
    std::lock_guard<std::mutex> guard(g_namespaces_mutex);
133

134
    ns = g_namespaces->FindNamespaceByClassLoader(env, class_loader);
135
    ns_descr = "class loader";
136

137
    if (ns == nullptr) {
138
      // This is the case where the classloader was not created by ApplicationLoaders
139
      // In this case we create an isolated not-shared namespace for it.
140
      const std::string empty_dex_path;
141
      Result<NativeLoaderNamespace*> res =
142
          CreateClassLoaderNamespaceLocked(env,
143
                                           target_sdk_version,
144
                                           class_loader,
145
                                           nativeloader::API_DOMAIN_DEFAULT,
146
                                           /*is_shared=*/false,
147
                                           empty_dex_path,
148
                                           library_path_j,
149
                                           /*permitted_path_j=*/nullptr,
150
                                           /*uses_library_list_j=*/nullptr);
151
      if (!res.ok()) {
152
        ALOGD("Failed to create isolated ns for %s (caller=%s)",
153
              path,
154
              caller_location == nullptr ? "<unknown>" : caller_location);
155
        *error_msg = strdup(res.error().message().c_str());
156
        return nullptr;
157
      }
158
      ns = res.value();
159
      ns_descr = "isolated";
160
    }
161
  }
162

163
  *needs_native_bridge = ns->IsBridged();
164
  Result<void*> handle = ns->Load(path);
165
  ALOGD("Load %s using %s ns %s (caller=%s): %s",
166
        path,
167
        ns_descr,
168
        ns->name().c_str(),
169
        caller_location == nullptr ? "<unknown>" : caller_location,
170
        handle.ok() ? "ok" : handle.error().message().c_str());
171
  if (!handle.ok()) {
172
    *error_msg = strdup(handle.error().message().c_str());
173
    return nullptr;
174
  }
175
  return handle.value();
176

177
#else   // !ART_TARGET_ANDROID
178
  UNUSED(env, target_sdk_version, class_loader, caller_location);
179

180
  // Do some best effort to emulate library-path support. It will not
181
  // work for dependencies.
182
  //
183
  // Note: null has a special meaning and must be preserved.
184
  std::string library_path;  // Empty string by default.
185
  if (library_path_j != nullptr && path != nullptr && path[0] != '/') {
186
    ScopedUtfChars library_path_utf_chars(env, library_path_j);
187
    library_path = library_path_utf_chars.c_str();
188
  }
189

190
  std::vector<std::string> library_paths = base::Split(library_path, ":");
191

192
  for (const std::string& lib_path : library_paths) {
193
    *needs_native_bridge = false;
194
    const char* path_arg;
195
    std::string complete_path;
196
    if (path == nullptr) {
197
      // Preserve null.
198
      path_arg = nullptr;
199
    } else {
200
      complete_path = lib_path;
201
      if (!complete_path.empty()) {
202
        complete_path.append("/");
203
      }
204
      complete_path.append(path);
205
      path_arg = complete_path.c_str();
206
    }
207
    void* handle = dlopen(path_arg, RTLD_NOW);
208
    if (handle != nullptr) {
209
      return handle;
210
    }
211
    if (NativeBridgeIsSupported(path_arg)) {
212
      *needs_native_bridge = true;
213
      handle = NativeBridgeLoadLibrary(path_arg, RTLD_NOW);
214
      if (handle != nullptr) {
215
        return handle;
216
      }
217
      *error_msg = strdup(NativeBridgeGetError());
218
    } else {
219
      *error_msg = strdup(dlerror());
220
    }
221
  }
222
  return nullptr;
223
#endif  // !ART_TARGET_ANDROID
224
}

1
void* android_dlopen_ext(const char* filename, int flags, const android_dlextinfo* info) {
2
  return mock->mock_dlopen_ext(false, filename, flags, TO_MOCK_NAMESPACE(info->library_namespace));
3
}

1
void* do_dlopen(const char* name, int flags,
2
                const android_dlextinfo* extinfo,
3
                const void* caller_addr) {
4
  std::string trace_prefix = std::string("dlopen: ") + (name == nullptr ? "(nullptr)" : name);
5
  ScopedTrace trace(trace_prefix.c_str());
6
  ScopedTrace loading_trace((trace_prefix + " - loading and linking").c_str());
7
  soinfo* const caller = find_containing_library(caller_addr);
8
  android_namespace_t* ns = get_caller_namespace(caller);
9

10
  LD_LOG(kLogDlopen,
11
         "dlopen(name=\"%s\", flags=0x%x, extinfo=%s, caller=\"%s\", caller_ns=%s@%p, targetSdkVersion=%i) ...",
12
         name,
13
         flags,
14
         android_dlextinfo_to_string(extinfo).c_str(),
15
         caller == nullptr ? "(null)" : caller->get_realpath(),
16
         ns == nullptr ? "(null)" : ns->get_name(),
17
         ns,
18
         get_application_target_sdk_version());
19

20
  auto purge_guard = android::base::make_scope_guard([&]() { purge_unused_memory(); });
21

22
  auto failure_guard = android::base::make_scope_guard(
23
      [&]() { LD_LOG(kLogDlopen, "... dlopen failed: %s", linker_get_error_buffer()); });
24

25
  if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NODELETE|RTLD_NOLOAD)) != 0) {
26
    DL_OPEN_ERR("invalid flags to dlopen: %x", flags);
27
    return nullptr;
28
  }
29

30
  if (extinfo != nullptr) {
31
    if ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0) {
32
      DL_OPEN_ERR("invalid extended flags to android_dlopen_ext: 0x%" PRIx64, extinfo->flags);
33
      return nullptr;
34
    }
35

36
    if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) == 0 &&
37
        (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
38
      DL_OPEN_ERR("invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without "
39
          "ANDROID_DLEXT_USE_LIBRARY_FD): 0x%" PRIx64, extinfo->flags);
40
      return nullptr;
41
    }
42

43
    if ((extinfo->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0) {
44
      if (extinfo->library_namespace == nullptr) {
45
        DL_OPEN_ERR("ANDROID_DLEXT_USE_NAMESPACE is set but extinfo->library_namespace is null");
46
        return nullptr;
47
      }
48
      ns = extinfo->library_namespace;
49
    }
50
  }
51

52
  // Workaround for dlopen(/system/lib/<soname>) when .so is in /apex. http://b/121248172
53
  // The workaround works only when targetSdkVersion < Q.
54
  std::string name_to_apex;
55
  if (translateSystemPathToApexPath(name, &name_to_apex)) {
56
    const char* new_name = name_to_apex.c_str();
57
    LD_LOG(kLogDlopen, "dlopen considering translation from %s to APEX path %s",
58
           name,
59
           new_name);
60
    // Some APEXs could be optionally disabled. Only translate the path
61
    // when the old file is absent and the new file exists.
62
    // TODO(b/124218500): Re-enable it once app compat issue is resolved
63
    /*
64
    if (file_exists(name)) {
65
      LD_LOG(kLogDlopen, "dlopen %s exists, not translating", name);
66
    } else
67
    */
68
    if (!file_exists(new_name)) {
69
      LD_LOG(kLogDlopen, "dlopen %s does not exist, not translating",
70
             new_name);
71
    } else {
72
      LD_LOG(kLogDlopen, "dlopen translation accepted: using %s", new_name);
73
      name = new_name;
74
    }
75
  }
76
  // End Workaround for dlopen(/system/lib/<soname>) when .so is in /apex.
77

78
  std::string translated_name_holder;
79

80
  assert(!g_is_hwasan || !g_is_asan);
81
  const char* translated_name = name;
82
  if (g_is_asan && translated_name != nullptr && translated_name[0] == '/') {
83
    char original_path[PATH_MAX];
84
    if (realpath(name, original_path) != nullptr) {
85
      translated_name_holder = std::string(kAsanLibDirPrefix) + original_path;
86
      if (file_exists(translated_name_holder.c_str())) {
87
        soinfo* si = nullptr;
88
        if (find_loaded_library_by_realpath(ns, original_path, true, &si)) {
89
          DL_WARN("linker_asan dlopen NOT translating \"%s\" -> \"%s\": library already loaded", name,
90
                  translated_name_holder.c_str());
91
        } else {
92
          DL_WARN("linker_asan dlopen translating \"%s\" -> \"%s\"", name, translated_name);
93
          translated_name = translated_name_holder.c_str();
94
        }
95
      }
96
    }
97
  } else if (g_is_hwasan && translated_name != nullptr && translated_name[0] == '/') {
98
    char original_path[PATH_MAX];
99
    if (realpath(name, original_path) != nullptr) {
100
      // Keep this the same as CreateHwasanPath in system/linkerconfig/modules/namespace.cc.
101
      std::string path(original_path);
102
      auto slash = path.rfind('/');
103
      if (slash != std::string::npos || slash != path.size() - 1) {
104
        translated_name_holder = path.substr(0, slash) + "/hwasan" + path.substr(slash);
105
      }
106
      if (!translated_name_holder.empty() && file_exists(translated_name_holder.c_str())) {
107
        soinfo* si = nullptr;
108
        if (find_loaded_library_by_realpath(ns, original_path, true, &si)) {
109
          DL_WARN("linker_hwasan dlopen NOT translating \"%s\" -> \"%s\": library already loaded",
110
                  name, translated_name_holder.c_str());
111
        } else {
112
          DL_WARN("linker_hwasan dlopen translating \"%s\" -> \"%s\"", name, translated_name);
113
          translated_name = translated_name_holder.c_str();
114
        }
115
      }
116
    }
117
  }
118
  ProtectedDataGuard guard;
119
  soinfo* si = find_library(ns, translated_name, flags, extinfo, caller);
120
  loading_trace.End();
121

122
  if (si != nullptr) {
123
    void* handle = si->to_handle();
124
    LD_LOG(kLogDlopen,
125
           "... dlopen calling constructors: realpath=\"%s\", soname=\"%s\", handle=%p",
126
           si->get_realpath(), si->get_soname(), handle);
127
    si->call_constructors();
128
    failure_guard.Disable();
129
    LD_LOG(kLogDlopen,
130
           "... dlopen successful: realpath=\"%s\", soname=\"%s\", handle=%p",
131
           si->get_realpath(), si->get_soname(), handle);
132
    return handle;
133
  }
134

135
  return nullptr;
136
}